From 458e87824b0f415e48e74a3792a2399af091881a Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 15 Feb 2017 08:40:23 -0800 Subject: [PATCH 001/218] 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 002/218] 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 7e58afadc47459a44dd8cd5d196506a8c8a9e151 Mon Sep 17 00:00:00 2001 From: Jason Ramsay Date: Thu, 9 Feb 2017 17:05:27 -0800 Subject: [PATCH 003/218] Bower_Components fix --- src/harness/unittests/typingsInstaller.ts | 50 ++++++++++++++++++++++- src/services/jsTyping.ts | 18 +++++--- 2 files changed, 60 insertions(+), 8 deletions(-) diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts index 29076df80f2..9ead1c7167d 100644 --- a/src/harness/unittests/typingsInstaller.ts +++ b/src/harness/unittests/typingsInstaller.ts @@ -692,7 +692,53 @@ namespace ts.projectSystem { checkProjectActualFiles(p, [app.path, jqueryDTS.path]); }); - it("configured projects discover from bower.josn", () => { + it("configured projects discover from bower_components", () => { + const app = { + path: "/app.js", + content: "" + }; + const jsconfig = { + path: "/jsconfig.json", + content: JSON.stringify({}) + }; + const jquery = { + path: "/bower_components/jquery/index.js", + content: "" + }; + const jqueryPackage = { + path: "/bower_components/jquery/package.json", + content: JSON.stringify({ name: "jquery" }) + }; + const jqueryDTS = { + path: "/tmp/node_modules/@types/jquery/index.d.ts", + content: "" + }; + const host = createServerHost([app, jsconfig, jquery, jqueryPackage]); + const installer = new (class extends Installer { + constructor() { + super(host, { globalTypingsCacheLocation: "/tmp", typesRegistry: createTypesRegistry("jquery") }); + } + installWorker(_requestId: number, _args: string[], _cwd: string, cb: server.typingsInstaller.RequestCompletedAction) { + const installedTypings = ["@types/jquery"]; + const typingFiles = [jqueryDTS]; + executeCommand(this, host, installedTypings, typingFiles, cb); + } + })(); + + const projectService = createProjectService(host, { useSingleInferredProject: true, typingsInstaller: installer }); + projectService.openClientFile(app.path); + + checkNumberOfProjects(projectService, { configuredProjects: 1 }); + const p = projectService.configuredProjects[0]; + checkProjectActualFiles(p, [app.path]); + + installer.installAll(/*expectedCount*/ 1); + + checkNumberOfProjects(projectService, { configuredProjects: 1 }); + checkProjectActualFiles(p, [app.path, jqueryDTS.path]); + }); + + it("configured projects discover from bower.json", () => { const app = { path: "/app.js", content: "" @@ -975,7 +1021,7 @@ namespace ts.projectSystem { } }); - it("should use cached locaitons", () => { + it("should use cached locations", () => { const f = { path: "/a/b/app.js", content: "" diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts index 248ceef1bd3..a7bd5139da1 100644 --- a/src/services/jsTyping.ts +++ b/src/services/jsTyping.ts @@ -99,8 +99,11 @@ namespace ts.JsTyping { const bowerJsonPath = combinePaths(searchDir, "bower.json"); getTypingNamesFromJson(bowerJsonPath, filesToWatch); + const bowerComponentsPath = combinePaths(searchDir, "bower_components"); + getTypingNamesFromPackagesFolder(bowerComponentsPath); + const nodeModulesPath = combinePaths(searchDir, "node_modules"); - getTypingNamesFromNodeModuleFolder(nodeModulesPath); + getTypingNamesFromPackagesFolder(nodeModulesPath); } getTypingNamesFromSourceFileNames(fileNames); @@ -199,17 +202,20 @@ namespace ts.JsTyping { } /** - * Infer typing names from node_module folder - * @param nodeModulesPath is the path to the "node_modules" folder + * Infer typing names from packages folder (ex: node_module, bower_components) + * @param packagesFolderPath is the path to the packages folder + */ - function getTypingNamesFromNodeModuleFolder(nodeModulesPath: string) { + function getTypingNamesFromPackagesFolder(packagesFolderPath: string) { + filesToWatch.push(packagesFolderPath); + // Todo: add support for ModuleResolutionHost too - if (!host.directoryExists(nodeModulesPath)) { + if (!host.directoryExists(packagesFolderPath)) { return; } const typingNames: string[] = []; - const fileNames = host.readDirectory(nodeModulesPath, [".json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2); + const fileNames = host.readDirectory(packagesFolderPath, [".json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2); for (const fileName of fileNames) { const normalizedFileName = normalizePath(fileName); if (getBaseFileName(normalizedFileName) !== "package.json") { From 8d1c9d5f9afb79497e162e02a5d9e4d7c879411d Mon Sep 17 00:00:00 2001 From: Jason Ramsay Date: Wed, 15 Feb 2017 17:33:57 -0800 Subject: [PATCH 004/218] Addressing CR comments --- src/harness/unittests/typingsInstaller.ts | 1 + src/services/jsTyping.ts | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts index 9ead1c7167d..faffb3eb45c 100644 --- a/src/harness/unittests/typingsInstaller.ts +++ b/src/harness/unittests/typingsInstaller.ts @@ -731,6 +731,7 @@ namespace ts.projectSystem { checkNumberOfProjects(projectService, { configuredProjects: 1 }); const p = projectService.configuredProjects[0]; checkProjectActualFiles(p, [app.path]); + checkWatchedFiles(host, [jsconfig.path, "/bower_components", "/node_modules"]); installer.installAll(/*expectedCount*/ 1); diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts index a7bd5139da1..e22d4432774 100644 --- a/src/services/jsTyping.ts +++ b/src/services/jsTyping.ts @@ -218,7 +218,8 @@ namespace ts.JsTyping { const fileNames = host.readDirectory(packagesFolderPath, [".json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2); for (const fileName of fileNames) { const normalizedFileName = normalizePath(fileName); - if (getBaseFileName(normalizedFileName) !== "package.json") { + const baseFileName = getBaseFileName(normalizedFileName); + if (baseFileName !== "package.json" && baseFileName !== "bower.json") { continue; } const result = readConfigFile(normalizedFileName, (path: string) => host.readFile(path)); @@ -230,7 +231,7 @@ namespace ts.JsTyping { // npm 3's package.json contains a "_requiredBy" field // we should include all the top level module names for npm 2, and only module names whose // "_requiredBy" field starts with "#" or equals "/" for npm 3. - if (packageJson._requiredBy && + if (baseFileName === "package.json" && packageJson._requiredBy && filter(packageJson._requiredBy, (r: string) => r[0] === "#" || r === "/").length === 0) { continue; } From 42a832ad3d13d151f91d1a098b6dcc4c5dd68381 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Thu, 26 Jan 2017 11:02:08 -0800 Subject: [PATCH 005/218] 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 006/218] 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 007/218] 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 3f198e6751892a531d20524300bba34544c02bf2 Mon Sep 17 00:00:00 2001 From: Jason Ramsay Date: Fri, 17 Feb 2017 13:54:07 -0800 Subject: [PATCH 008/218] Adding cancellation token checks for lower priority tasks --- .../unittests/tsserverProjectSystem.ts | 82 +++++++ src/services/navigationBar.ts | 232 +++++++++--------- src/services/outliningElementsCollector.ts | 4 +- src/services/services.ts | 6 +- 4 files changed, 207 insertions(+), 117 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 92ec0b4ee0e..01e484fd4ba 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -3460,6 +3460,88 @@ namespace ts.projectSystem { return JSON.parse(server.extractMessage(host.getOutput()[n])); } }); + it("Lower priority tasks are cancellable", () => { + const f1 = { + path: "/a/app.ts", + content: `{ let x = 1; } var foo = "foo"; var bar = "bar"; var fooBar = "fooBar";` + }; + const config = { + path: "/a/tsconfig.json", + content: JSON.stringify({ + compilerOptions: {} + }) + }; + + let requestToCancel = -1; + let isCancellationRequestedCount = 0; + let cancelAfterRequest = 3; + let operationCanceledExceptionThrown = false; + const cancellationToken: server.ServerCancellationToken = (function () { + let currentId: number; + return { + setRequest(requestId) { + currentId = requestId; + }, + resetRequest(requestId) { + assert.equal(requestId, currentId, "unexpected request id in cancellation") + currentId = undefined; + }, + isCancellationRequested() { + isCancellationRequestedCount++; + return requestToCancel === currentId && isCancellationRequestedCount >= cancelAfterRequest; + } + } + })(); + const host = createServerHost([f1, config]); + const session = createSession(host, /*typingsInstaller*/ undefined, () => { }, cancellationToken); + { + session.executeCommandSeq({ + command: "open", + arguments: { file: f1.path } + }); + + // send navbar request (normal priority) + session.executeCommandSeq({ + command: "navbar", + arguments: { file: f1.path } + }); + + // ensure the nav bar request can be canceled + verifyExecuteCommandSeqIsCancellable({ + command: "navbar", + arguments: { file: f1.path } + }); + + // send outlining spans request (normal priority) + session.executeCommandSeq({ + command: "outliningSpans", + arguments: { file: f1.path } + }); + + // ensure the outlining spans request can be canceled + verifyExecuteCommandSeqIsCancellable({ + command: "outliningSpans", + arguments: { file: f1.path } + }); + } + + function verifyExecuteCommandSeqIsCancellable(request: Partial) { + // Set the next request to be cancellable + // The cancellation token will cancel the request the third time + // isCancellationRequested() is called. + requestToCancel = session.getNextSeq(); + isCancellationRequestedCount = 0; + operationCanceledExceptionThrown = false; + + try { + session.executeCommandSeq(request); + } catch (e) { + assert(e instanceof OperationCanceledException); + operationCanceledExceptionThrown = true; + } + assert(operationCanceledExceptionThrown); + } + }); }); describe("maxNodeModuleJsDepth for inferred projects", () => { diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts index 25059d1f57d..37b6bedbd5b 100644 --- a/src/services/navigationBar.ts +++ b/src/services/navigationBar.ts @@ -14,16 +14,16 @@ namespace ts.NavigationBar { indent: number; // # of parents } - export function getNavigationBarItems(sourceFile: SourceFile): NavigationBarItem[] { + export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarItem[] { curSourceFile = sourceFile; - const result = map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem); + const result = map(topLevelItems(rootNavigationBarNode(sourceFile, cancellationToken)), convertToTopLevelItem); curSourceFile = undefined; return result; } - export function getNavigationTree(sourceFile: SourceFile): NavigationTree { + export function getNavigationTree(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationTree { curSourceFile = sourceFile; - const result = convertToTree(rootNavigationBarNode(sourceFile)); + const result = convertToTree(rootNavigationBarNode(sourceFile, cancellationToken)); curSourceFile = undefined; return result; } @@ -55,12 +55,12 @@ namespace ts.NavigationBar { const parentsStack: NavigationBarNode[] = []; let parent: NavigationBarNode; - function rootNavigationBarNode(sourceFile: SourceFile): NavigationBarNode { + function rootNavigationBarNode(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarNode { Debug.assert(!parentsStack.length); const root: NavigationBarNode = { node: sourceFile, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 }; parent = root; for (const statement of sourceFile.statements) { - addChildrenRecursively(statement); + addChildrenRecursively(statement, cancellationToken); } endNode(); Debug.assert(!parent && !parentsStack.length); @@ -103,138 +103,144 @@ namespace ts.NavigationBar { parent = parentsStack.pop(); } - function addNodeWithRecursiveChild(node: Node, child: Node): void { + function addNodeWithRecursiveChild(node: Node, child: Node, addChildrenRecursively: (node: Node) => void): void { startNode(node); addChildrenRecursively(child); endNode(); } /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ - function addChildrenRecursively(node: Node): void { - if (!node || isToken(node)) { - return; - } + function addChildrenRecursively(node: Node, cancellationToken: CancellationToken): void { + function addChildrenRecursively(node: Node): void { + cancellationToken.throwIfCancellationRequested(); - switch (node.kind) { - case SyntaxKind.Constructor: - // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it. - const ctr = node; - addNodeWithRecursiveChild(ctr, ctr.body); + if (!node || isToken(node)) { + return; + } - // Parameter properties are children of the class, not the constructor. - for (const param of ctr.parameters) { - if (isParameterPropertyDeclaration(param)) { - addLeafNode(param); + switch (node.kind) { + case SyntaxKind.Constructor: + // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it. + const ctr = node; + addNodeWithRecursiveChild(ctr, ctr.body, addChildrenRecursively); + + // Parameter properties are children of the class, not the constructor. + for (const param of ctr.parameters) { + if (isParameterPropertyDeclaration(param)) { + addLeafNode(param); + } } - } - break; + break; - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.MethodSignature: - if (!hasDynamicName((node))) { - addNodeWithRecursiveChild(node, (node).body); - } - break; + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.MethodSignature: + if (!hasDynamicName((node))) { + addNodeWithRecursiveChild(node, (node).body, addChildrenRecursively); + } + break; - case SyntaxKind.PropertyDeclaration: - case SyntaxKind.PropertySignature: - if (!hasDynamicName((node))) { - addLeafNode(node); - } - break; + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.PropertySignature: + if (!hasDynamicName((node))) { + addLeafNode(node); + } + break; - case SyntaxKind.ImportClause: - const importClause = node; - // Handle default import case e.g.: - // import d from "mod"; - if (importClause.name) { - addLeafNode(importClause); - } + case SyntaxKind.ImportClause: + const importClause = node; + // Handle default import case e.g.: + // import d from "mod"; + if (importClause.name) { + addLeafNode(importClause); + } - // Handle named bindings in imports e.g.: - // import * as NS from "mod"; - // import {a, b as B} from "mod"; - const {namedBindings} = importClause; - if (namedBindings) { - if (namedBindings.kind === SyntaxKind.NamespaceImport) { - addLeafNode(namedBindings); + // Handle named bindings in imports e.g.: + // import * as NS from "mod"; + // import {a, b as B} from "mod"; + const {namedBindings} = importClause; + if (namedBindings) { + if (namedBindings.kind === SyntaxKind.NamespaceImport) { + addLeafNode(namedBindings); + } + else { + for (const element of (namedBindings).elements) { + addLeafNode(element); + } + } + } + break; + + case SyntaxKind.BindingElement: + case SyntaxKind.VariableDeclaration: + const decl = node; + const name = decl.name; + if (isBindingPattern(name)) { + addChildrenRecursively(name); + } + else if (decl.initializer && isFunctionOrClassExpression(decl.initializer)) { + // For `const x = function() {}`, just use the function node, not the const. + addChildrenRecursively(decl.initializer); } else { - for (const element of (namedBindings).elements) { - addLeafNode(element); + addNodeWithRecursiveChild(decl, decl.initializer, addChildrenRecursively); + } + break; + + case SyntaxKind.ArrowFunction: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + addNodeWithRecursiveChild(node, (node).body, addChildrenRecursively); + break; + + case SyntaxKind.EnumDeclaration: + startNode(node); + for (const member of (node).members) { + if (!isComputedProperty(member)) { + addLeafNode(member); } } - } - break; + endNode(); + break; - case SyntaxKind.BindingElement: - case SyntaxKind.VariableDeclaration: - const decl = node; - const name = decl.name; - if (isBindingPattern(name)) { - addChildrenRecursively(name); - } - else if (decl.initializer && isFunctionOrClassExpression(decl.initializer)) { - // For `const x = function() {}`, just use the function node, not the const. - addChildrenRecursively(decl.initializer); - } - else { - addNodeWithRecursiveChild(decl, decl.initializer); - } - break; - - case SyntaxKind.ArrowFunction: - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.FunctionExpression: - addNodeWithRecursiveChild(node, (node).body); - break; - - case SyntaxKind.EnumDeclaration: - startNode(node); - for (const member of (node).members) { - if (!isComputedProperty(member)) { - addLeafNode(member); + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + case SyntaxKind.InterfaceDeclaration: + startNode(node); + for (const member of (node).members) { + addChildrenRecursively(member); } - } - endNode(); - break; + endNode(); + break; - case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: - case SyntaxKind.InterfaceDeclaration: - startNode(node); - for (const member of (node).members) { - addChildrenRecursively(member); - } - endNode(); - break; + case SyntaxKind.ModuleDeclaration: + addNodeWithRecursiveChild(node, getInteriorModule(node).body, addChildrenRecursively); + break; - case SyntaxKind.ModuleDeclaration: - addNodeWithRecursiveChild(node, getInteriorModule(node).body); - break; + case SyntaxKind.ExportSpecifier: + case SyntaxKind.ImportEqualsDeclaration: + case SyntaxKind.IndexSignature: + case SyntaxKind.CallSignature: + case SyntaxKind.ConstructSignature: + case SyntaxKind.TypeAliasDeclaration: + addLeafNode(node); + break; - case SyntaxKind.ExportSpecifier: - case SyntaxKind.ImportEqualsDeclaration: - case SyntaxKind.IndexSignature: - case SyntaxKind.CallSignature: - case SyntaxKind.ConstructSignature: - case SyntaxKind.TypeAliasDeclaration: - addLeafNode(node); - break; - - default: - forEach(node.jsDoc, jsDoc => { - forEach(jsDoc.tags, tag => { - if (tag.kind === SyntaxKind.JSDocTypedefTag) { - addLeafNode(tag); - } + default: + forEach(node.jsDoc, jsDoc => { + forEach(jsDoc.tags, tag => { + if (tag.kind === SyntaxKind.JSDocTypedefTag) { + addLeafNode(tag); + } + }); }); - }); - forEachChild(node, addChildrenRecursively); + forEachChild(node, addChildrenRecursively); + } } + + addChildrenRecursively(node); } /** Merge declarations of the same kind. */ diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 2ad20a7ed0c..96a7c9a3c4a 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -1,6 +1,6 @@ /* @internal */ namespace ts.OutliningElementsCollector { - export function collectElements(sourceFile: SourceFile): OutliningSpan[] { + export function collectElements(sourceFile: SourceFile, cancellationToken: CancellationToken): OutliningSpan[] { const elements: OutliningSpan[] = []; const collapseText = "..."; @@ -38,6 +38,7 @@ namespace ts.OutliningElementsCollector { let singleLineCommentCount = 0; for (const currentComment of comments) { + cancellationToken.throwIfCancellationRequested(); // For single line comments, combine consecutive ones (2 or more) into // a single span from the start of the first till the end of the last @@ -84,6 +85,7 @@ namespace ts.OutliningElementsCollector { let depth = 0; const maxDepth = 20; function walk(n: Node): void { + cancellationToken.throwIfCancellationRequested(); if (depth > maxDepth) { return; } diff --git a/src/services/services.ts b/src/services/services.ts index c1b719d3477..cef307eb8fd 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1541,11 +1541,11 @@ namespace ts { } function getNavigationBarItems(fileName: string): NavigationBarItem[] { - return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName)); + return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); } function getNavigationTree(fileName: string): NavigationTree { - return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName)); + return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); } function isTsOrTsxFile(fileName: string): boolean { @@ -1584,7 +1584,7 @@ namespace ts { function getOutliningSpans(fileName: string): OutliningSpan[] { // doesn't use compiler - no need to synchronize with host const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return OutliningElementsCollector.collectElements(sourceFile); + return OutliningElementsCollector.collectElements(sourceFile, cancellationToken); } function getBraceMatchingAtPosition(fileName: string, position: number) { From a37053f780583e979386a8ff7802e51e64e5bf67 Mon Sep 17 00:00:00 2001 From: Jason Ramsay Date: Wed, 22 Feb 2017 09:54:45 -0800 Subject: [PATCH 009/218] Addressing CR comments - Adding a throttle - Refactor - Navbar reset onCancel --- src/compiler/program.ts | 52 +++++----- src/compiler/types.ts | 2 + .../unittests/tsserverProjectSystem.ts | 94 ++++++++++--------- src/services/navigationBar.ts | 17 ++-- src/services/outliningElementsCollector.ts | 2 +- src/services/services.ts | 48 +++++++++- src/services/shims.ts | 23 ----- src/services/types.ts | 1 + 8 files changed, 137 insertions(+), 102 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 62f3c066442..083c812464d 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -72,6 +72,20 @@ namespace ts { return getNormalizedPathFromPathComponents(commonPathComponents); } + /* @internal */ + export function runWithCancellationToken(func: () => T, onCancel?: () => void): T { + try { + return func(); + } + catch (e) { + if (e instanceof OperationCanceledException && onCancel) { + // We were canceled while performing the operation. + onCancel(); + } + throw e; + } + } + interface OutputFingerprint { hash: string; byteOrderMark: boolean; @@ -873,29 +887,19 @@ namespace ts { return sourceFile.parseDiagnostics; } - function runWithCancellationToken(func: () => T): T { - try { - return func(); - } - catch (e) { - if (e instanceof OperationCanceledException) { - // We were canceled while performing the operation. Because our type checker - // might be a bad state, we need to throw it away. - // - // Note: we are overly aggressive here. We do not actually *have* to throw away - // the "noDiagnosticsTypeChecker". However, for simplicity, i'd like to keep - // the lifetimes of these two TypeCheckers the same. Also, we generally only - // cancel when the user has made a change anyways. And, in that case, we (the - // program instance) will get thrown away anyways. So trying to keep one of - // these type checkers alive doesn't serve much purpose. - noDiagnosticsTypeChecker = undefined; - diagnosticsProducingTypeChecker = undefined; - } - - throw e; - } + function onCancel() { + // Because our type checker might be a bad state, we need to throw it away. + // Note: we are overly aggressive here. We do not actually *have* to throw away + // the "noDiagnosticsTypeChecker". However, for simplicity, i'd like to keep + // the lifetimes of these two TypeCheckers the same. Also, we generally only + // cancel when the user has made a change anyways. And, in that case, we (the + // program instance) will get thrown away anyways. So trying to keep one of + // these type checkers alive doesn't serve much purpose. + noDiagnosticsTypeChecker = undefined; + diagnosticsProducingTypeChecker = undefined; } + function getSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { return runWithCancellationToken(() => { const typeChecker = getDiagnosticsProducingTypeChecker(); @@ -910,7 +914,7 @@ namespace ts { const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName); return bindDiagnostics.concat(checkDiagnostics, fileProcessingDiagnosticsInFile, programDiagnosticsInFile); - }); + }, onCancel); } function getJavaScriptSyntacticDiagnosticsForFile(sourceFile: SourceFile): Diagnostic[] { @@ -1089,7 +1093,7 @@ namespace ts { function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): Diagnostic { return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2); } - }); + }, onCancel); } function getDeclarationDiagnosticsWorker(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { @@ -1097,7 +1101,7 @@ namespace ts { const resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken); // Don't actually write any files since we're just getting diagnostics. return ts.getDeclarationDiagnostics(getEmitHost(noop), resolver, sourceFile); - }); + }, onCancel); } function getDeclarationDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 7fc77b48708..17adbd2ea3f 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2262,6 +2262,8 @@ /** @throws OperationCanceledException if isCancellationRequested is true */ throwIfCancellationRequested(): void; + + throttleWaitMilliseconds?: number; } export interface Program extends ScriptReferenceHost { diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 01e484fd4ba..ee4273c3d2e 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -547,6 +547,45 @@ namespace ts.projectSystem { readonly getEnvironmentVariable = notImplemented; } + export class TestServerCancellationToken implements server.ServerCancellationToken { + private currentId = -1; + private requestToCancel = -1; + private isCancellationRequestedCount = 0; + + constructor(private cancelAfterRequest = 0) { + } + + get throttleWaitMilliseconds() { + // For testing purposes disable the throttle + return 0; + } + + setRequest(requestId: number) { + this.currentId = requestId; + } + + setRequestToCancel(requestId: number) { + this.resetToken(); + this.requestToCancel = requestId; + } + + resetRequest(requestId: number) { + assert.equal(requestId, this.currentId, "unexpected request id in cancellation") + this.currentId = undefined; + } + + isCancellationRequested() { + this.isCancellationRequestedCount++; + return this.requestToCancel === this.currentId && this.isCancellationRequestedCount >= this.cancelAfterRequest; + } + + resetToken() { + this.currentId = -1; + this.isCancellationRequestedCount = 0; + this.requestToCancel = -1; + } + } + export function makeSessionRequest(command: string, args: T) { const newRequest: protocol.Request = { seq: 0, @@ -3324,22 +3363,7 @@ namespace ts.projectSystem { }) }; - let requestToCancel = -1; - const cancellationToken: server.ServerCancellationToken = (function(){ - let currentId: number; - return { - setRequest(requestId) { - currentId = requestId; - }, - resetRequest(requestId) { - assert.equal(requestId, currentId, "unexpected request id in cancellation") - currentId = undefined; - }, - isCancellationRequested() { - return requestToCancel === currentId; - } - } - })(); + const cancellationToken = new TestServerCancellationToken(); const host = createServerHost([f1, config]); const session = createSession(host, /*typingsInstaller*/ undefined, () => {}, cancellationToken); { @@ -3374,13 +3398,13 @@ namespace ts.projectSystem { host.clearOutput(); // cancel previously issued Geterr - requestToCancel = getErrId; + cancellationToken.setRequestToCancel(getErrId); host.runQueuedTimeoutCallbacks(); assert.equal(host.getOutput().length, 1, "expect 1 message"); verifyRequestCompleted(getErrId, 0); - requestToCancel = -1; + cancellationToken.resetToken(); } { const getErrId = session.getNextSeq(); @@ -3397,12 +3421,12 @@ namespace ts.projectSystem { assert.equal(e1.event, "syntaxDiag"); host.clearOutput(); - requestToCancel = getErrId; + cancellationToken.setRequestToCancel(getErrId); host.runQueuedImmediateCallbacks(); assert.equal(host.getOutput().length, 1, "expect 1 message"); verifyRequestCompleted(getErrId, 0); - requestToCancel = -1; + cancellationToken.resetToken(); } { const getErrId = session.getNextSeq(); @@ -3425,7 +3449,7 @@ namespace ts.projectSystem { assert.equal(e2.event, "semanticDiag"); verifyRequestCompleted(getErrId, 1); - requestToCancel = -1; + cancellationToken.resetToken(); } { const getErr1 = session.getNextSeq(); @@ -3472,26 +3496,8 @@ namespace ts.projectSystem { }) }; - let requestToCancel = -1; - let isCancellationRequestedCount = 0; - let cancelAfterRequest = 3; let operationCanceledExceptionThrown = false; - const cancellationToken: server.ServerCancellationToken = (function () { - let currentId: number; - return { - setRequest(requestId) { - currentId = requestId; - }, - resetRequest(requestId) { - assert.equal(requestId, currentId, "unexpected request id in cancellation") - currentId = undefined; - }, - isCancellationRequested() { - isCancellationRequestedCount++; - return requestToCancel === currentId && isCancellationRequestedCount >= cancelAfterRequest; - } - } - })(); + const cancellationToken = new TestServerCancellationToken(/*cancelAfterRequest*/ 3); const host = createServerHost([f1, config]); const session = createSession(host, /*typingsInstaller*/ undefined, () => { }, cancellationToken); { @@ -3529,17 +3535,17 @@ namespace ts.projectSystem { // Set the next request to be cancellable // The cancellation token will cancel the request the third time // isCancellationRequested() is called. - requestToCancel = session.getNextSeq(); - isCancellationRequestedCount = 0; + cancellationToken.setRequestToCancel(session.getNextSeq()); operationCanceledExceptionThrown = false; try { session.executeCommandSeq(request); - } catch (e) { + } + catch (e) { assert(e instanceof OperationCanceledException); operationCanceledExceptionThrown = true; } - assert(operationCanceledExceptionThrown); + assert(operationCanceledExceptionThrown, "Operation Canceled Exception not thrown for request: " + JSON.stringify(request)); } }); }); diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts index 37b6bedbd5b..2910a3528d0 100644 --- a/src/services/navigationBar.ts +++ b/src/services/navigationBar.ts @@ -14,21 +14,24 @@ namespace ts.NavigationBar { indent: number; // # of parents } - export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarItem[] { + export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): NavigationBarItem[] { + curCancellationToken = cancellationToken; curSourceFile = sourceFile; - const result = map(topLevelItems(rootNavigationBarNode(sourceFile, cancellationToken)), convertToTopLevelItem); + const result = runWithCancellationToken(() => map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem), () => curSourceFile = undefined); curSourceFile = undefined; return result; } - export function getNavigationTree(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationTree { + export function getNavigationTree(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): NavigationTree { + curCancellationToken = cancellationToken; curSourceFile = sourceFile; - const result = convertToTree(rootNavigationBarNode(sourceFile, cancellationToken)); + const result = runWithCancellationToken(() => convertToTree(rootNavigationBarNode(sourceFile)), () => curSourceFile = undefined); curSourceFile = undefined; return result; } // Keep sourceFile handy so we don't have to search for it every time we need to call `getText`. + let curCancellationToken: ThrottledCancellationToken; let curSourceFile: SourceFile; function nodeText(node: Node): string { return node.getText(curSourceFile); @@ -55,12 +58,12 @@ namespace ts.NavigationBar { const parentsStack: NavigationBarNode[] = []; let parent: NavigationBarNode; - function rootNavigationBarNode(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarNode { + function rootNavigationBarNode(sourceFile: SourceFile): NavigationBarNode { Debug.assert(!parentsStack.length); const root: NavigationBarNode = { node: sourceFile, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 }; parent = root; for (const statement of sourceFile.statements) { - addChildrenRecursively(statement, cancellationToken); + addChildrenRecursively(statement, curCancellationToken); } endNode(); Debug.assert(!parent && !parentsStack.length); @@ -110,7 +113,7 @@ namespace ts.NavigationBar { } /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ - function addChildrenRecursively(node: Node, cancellationToken: CancellationToken): void { + function addChildrenRecursively(node: Node, cancellationToken: ThrottledCancellationToken): void { function addChildrenRecursively(node: Node): void { cancellationToken.throwIfCancellationRequested(); diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 96a7c9a3c4a..1b7618c0327 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -1,6 +1,6 @@ /* @internal */ namespace ts.OutliningElementsCollector { - export function collectElements(sourceFile: SourceFile, cancellationToken: CancellationToken): OutliningSpan[] { + export function collectElements(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): OutliningSpan[] { const elements: OutliningSpan[] = []; const collapseText = "..."; diff --git a/src/services/services.ts b/src/services/services.ts index cef307eb8fd..6cf50940fb7 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -958,7 +958,12 @@ namespace ts { } class CancellationTokenObject implements CancellationToken { + throttleWaitMilliseconds?: number; + constructor(private cancellationToken: HostCancellationToken) { + if (cancellationToken.throttleWaitMilliseconds !== undefined) { + this.throttleWaitMilliseconds = cancellationToken.throttleWaitMilliseconds; + } } public isCancellationRequested() { @@ -972,6 +977,42 @@ namespace ts { } } + /** A cancellation that throttles calls to the host */ + export class ThrottledCancellationToken implements CancellationToken { + // Store when we last tried to cancel. Checking cancellation can be expensive (as we have + // to marshall over to the host layer). So we only bother actually checking once enough + // time has passed. + private lastCancellationCheckTime = 0; + // The minuimum duration to wait in milliseconds before querying host. + // The default of 10 milliseconds will be used unless throttleWaitMilliseconds + // is specified in the host cancellation token. + throttleWaitMilliseconds: number = 10; + + constructor(private hostCancellationToken: HostCancellationToken) { + if (hostCancellationToken.throttleWaitMilliseconds !== undefined) { + this.throttleWaitMilliseconds = hostCancellationToken.throttleWaitMilliseconds; + } + } + + public isCancellationRequested(): boolean { + const time = timestamp(); + const duration = Math.abs(time - this.lastCancellationCheckTime); + if (duration >= this.throttleWaitMilliseconds) { + // Check no more than the min wait in milliseconds + this.lastCancellationCheckTime = time; + return this.hostCancellationToken.isCancellationRequested(); + } + + return false; + } + + public throwIfCancellationRequested(): void { + if (this.isCancellationRequested()) { + throw new OperationCanceledException(); + } + } + } + export function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory())): LanguageService { @@ -984,6 +1025,7 @@ namespace ts { const useCaseSensitivefileNames = host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(); const cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken()); + const throttledCancellationToken = new ThrottledCancellationToken(cancellationToken); const currentDirectory = host.getCurrentDirectory(); // Check if the localized messages json is set, otherwise query the host for it @@ -1541,11 +1583,11 @@ namespace ts { } function getNavigationBarItems(fileName: string): NavigationBarItem[] { - return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); + return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), throttledCancellationToken); } function getNavigationTree(fileName: string): NavigationTree { - return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); + return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), throttledCancellationToken); } function isTsOrTsxFile(fileName: string): boolean { @@ -1584,7 +1626,7 @@ namespace ts { function getOutliningSpans(fileName: string): OutliningSpan[] { // doesn't use compiler - no need to synchronize with host const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return OutliningElementsCollector.collectElements(sourceFile, cancellationToken); + return OutliningElementsCollector.collectElements(sourceFile, throttledCancellationToken); } function getBraceMatchingAtPosition(fileName: string, position: number) { diff --git a/src/services/shims.ts b/src/services/shims.ts index 6fe9aed144e..de2fd39b8a8 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -469,29 +469,6 @@ namespace ts { } } - /** A cancellation that throttles calls to the host */ - class ThrottledCancellationToken implements HostCancellationToken { - // Store when we last tried to cancel. Checking cancellation can be expensive (as we have - // to marshall over to the host layer). So we only bother actually checking once enough - // time has passed. - private lastCancellationCheckTime = 0; - - constructor(private hostCancellationToken: HostCancellationToken) { - } - - public isCancellationRequested(): boolean { - const time = timestamp(); - const duration = Math.abs(time - this.lastCancellationCheckTime); - if (duration > 10) { - // Check no more than once every 10 ms. - this.lastCancellationCheckTime = time; - return this.hostCancellationToken.isCancellationRequested(); - } - - return false; - } - } - export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost { public directoryExists: (directoryName: string) => boolean; diff --git a/src/services/types.ts b/src/services/types.ts index a6ca3852597..f9c33e15dfe 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -121,6 +121,7 @@ namespace ts { export interface HostCancellationToken { isCancellationRequested(): boolean; + throttleWaitMilliseconds?: number; } // From 497d8d3a58f40729941d08de64ee082e9b0d8154 Mon Sep 17 00:00:00 2001 From: Jason Ramsay Date: Wed, 22 Feb 2017 15:33:57 -0800 Subject: [PATCH 010/218] Updates from CR comments --- src/compiler/program.ts | 38 ++++++++++++++++++++++------------- src/services/navigationBar.ts | 26 +++++++++++++++--------- 2 files changed, 40 insertions(+), 24 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 083c812464d..b94efe18222 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -887,18 +887,28 @@ namespace ts { return sourceFile.parseDiagnostics; } - function onCancel() { - // Because our type checker might be a bad state, we need to throw it away. - // Note: we are overly aggressive here. We do not actually *have* to throw away - // the "noDiagnosticsTypeChecker". However, for simplicity, i'd like to keep - // the lifetimes of these two TypeCheckers the same. Also, we generally only - // cancel when the user has made a change anyways. And, in that case, we (the - // program instance) will get thrown away anyways. So trying to keep one of - // these type checkers alive doesn't serve much purpose. - noDiagnosticsTypeChecker = undefined; - diagnosticsProducingTypeChecker = undefined; - } + function runWithCancellationToken(func: () => T): T { + try { + return func(); + } + catch (e) { + if (e instanceof OperationCanceledException) { + // We were canceled while performing the operation. Because our type checker + // might be a bad state, we need to throw it away. + // + // Note: we are overly aggressive here. We do not actually *have* to throw away + // the "noDiagnosticsTypeChecker". However, for simplicity, i'd like to keep + // the lifetimes of these two TypeCheckers the same. Also, we generally only + // cancel when the user has made a change anyways. And, in that case, we (the + // program instance) will get thrown away anyways. So trying to keep one of + // these type checkers alive doesn't serve much purpose. + noDiagnosticsTypeChecker = undefined; + diagnosticsProducingTypeChecker = undefined; + } + throw e; + } + } function getSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { return runWithCancellationToken(() => { @@ -914,7 +924,7 @@ namespace ts { const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName); return bindDiagnostics.concat(checkDiagnostics, fileProcessingDiagnosticsInFile, programDiagnosticsInFile); - }, onCancel); + }); } function getJavaScriptSyntacticDiagnosticsForFile(sourceFile: SourceFile): Diagnostic[] { @@ -1093,7 +1103,7 @@ namespace ts { function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): Diagnostic { return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2); } - }, onCancel); + }); } function getDeclarationDiagnosticsWorker(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { @@ -1101,7 +1111,7 @@ namespace ts { const resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken); // Don't actually write any files since we're just getting diagnostics. return ts.getDeclarationDiagnostics(getEmitHost(noop), resolver, sourceFile); - }, onCancel); + }); } function getDeclarationDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts index 2910a3528d0..62ead677d8b 100644 --- a/src/services/navigationBar.ts +++ b/src/services/navigationBar.ts @@ -17,21 +17,27 @@ namespace ts.NavigationBar { export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): NavigationBarItem[] { curCancellationToken = cancellationToken; curSourceFile = sourceFile; - const result = runWithCancellationToken(() => map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem), () => curSourceFile = undefined); - curSourceFile = undefined; - return result; + try { + return map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem); + } + finally { + curSourceFile = undefined; + } } export function getNavigationTree(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): NavigationTree { curCancellationToken = cancellationToken; curSourceFile = sourceFile; - const result = runWithCancellationToken(() => convertToTree(rootNavigationBarNode(sourceFile)), () => curSourceFile = undefined); - curSourceFile = undefined; - return result; + try { + return convertToTree(rootNavigationBarNode(sourceFile)); + } + finally { + curSourceFile = undefined; + } } // Keep sourceFile handy so we don't have to search for it every time we need to call `getText`. - let curCancellationToken: ThrottledCancellationToken; + let curCancellationToken: CancellationToken; let curSourceFile: SourceFile; function nodeText(node: Node): string { return node.getText(curSourceFile); @@ -63,7 +69,7 @@ namespace ts.NavigationBar { const root: NavigationBarNode = { node: sourceFile, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 }; parent = root; for (const statement of sourceFile.statements) { - addChildrenRecursively(statement, curCancellationToken); + addChildrenRecursively(statement); } endNode(); Debug.assert(!parent && !parentsStack.length); @@ -113,9 +119,9 @@ namespace ts.NavigationBar { } /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ - function addChildrenRecursively(node: Node, cancellationToken: ThrottledCancellationToken): void { + function addChildrenRecursively(node: Node): void { function addChildrenRecursively(node: Node): void { - cancellationToken.throwIfCancellationRequested(); + curCancellationToken.throwIfCancellationRequested(); if (!node || isToken(node)) { return; From e62108cf9b5dbf678bf596def315ab766b82fa25 Mon Sep 17 00:00:00 2001 From: Jason Ramsay Date: Wed, 22 Feb 2017 17:33:11 -0800 Subject: [PATCH 011/218] Removing throttling until tests prove it is required --- src/compiler/program.ts | 14 - src/compiler/types.ts | 2 - .../unittests/tsserverProjectSystem.ts | 9 +- src/services/navigationBar.ts | 258 +++++++++--------- src/services/outliningElementsCollector.ts | 2 +- src/services/services.ts | 48 +--- src/services/shims.ts | 23 ++ src/services/types.ts | 1 - 8 files changed, 156 insertions(+), 201 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index b94efe18222..62f3c066442 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -72,20 +72,6 @@ namespace ts { return getNormalizedPathFromPathComponents(commonPathComponents); } - /* @internal */ - export function runWithCancellationToken(func: () => T, onCancel?: () => void): T { - try { - return func(); - } - catch (e) { - if (e instanceof OperationCanceledException && onCancel) { - // We were canceled while performing the operation. - onCancel(); - } - throw e; - } - } - interface OutputFingerprint { hash: string; byteOrderMark: boolean; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 17adbd2ea3f..7fc77b48708 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2262,8 +2262,6 @@ /** @throws OperationCanceledException if isCancellationRequested is true */ throwIfCancellationRequested(): void; - - throttleWaitMilliseconds?: number; } export interface Program extends ScriptReferenceHost { diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index ee4273c3d2e..d9abb0a9078 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -555,11 +555,6 @@ namespace ts.projectSystem { constructor(private cancelAfterRequest = 0) { } - get throttleWaitMilliseconds() { - // For testing purposes disable the throttle - return 0; - } - setRequest(requestId: number) { this.currentId = requestId; } @@ -3495,8 +3490,6 @@ namespace ts.projectSystem { compilerOptions: {} }) }; - - let operationCanceledExceptionThrown = false; const cancellationToken = new TestServerCancellationToken(/*cancelAfterRequest*/ 3); const host = createServerHost([f1, config]); const session = createSession(host, /*typingsInstaller*/ undefined, () => { }, cancellationToken); @@ -3536,7 +3529,7 @@ namespace ts.projectSystem { // The cancellation token will cancel the request the third time // isCancellationRequested() is called. cancellationToken.setRequestToCancel(session.getNextSeq()); - operationCanceledExceptionThrown = false; + let operationCanceledExceptionThrown = false; try { session.executeCommandSeq(request); diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts index 62ead677d8b..811762fb736 100644 --- a/src/services/navigationBar.ts +++ b/src/services/navigationBar.ts @@ -14,7 +14,7 @@ namespace ts.NavigationBar { indent: number; // # of parents } - export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): NavigationBarItem[] { + export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarItem[] { curCancellationToken = cancellationToken; curSourceFile = sourceFile; try { @@ -22,10 +22,11 @@ namespace ts.NavigationBar { } finally { curSourceFile = undefined; + curCancellationToken = undefined; } } - export function getNavigationTree(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): NavigationTree { + export function getNavigationTree(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationTree { curCancellationToken = cancellationToken; curSourceFile = sourceFile; try { @@ -33,6 +34,7 @@ namespace ts.NavigationBar { } finally { curSourceFile = undefined; + curCancellationToken = undefined; } } @@ -112,7 +114,7 @@ namespace ts.NavigationBar { parent = parentsStack.pop(); } - function addNodeWithRecursiveChild(node: Node, child: Node, addChildrenRecursively: (node: Node) => void): void { + function addNodeWithRecursiveChild(node: Node, child: Node): void { startNode(node); addChildrenRecursively(child); endNode(); @@ -120,136 +122,132 @@ namespace ts.NavigationBar { /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ function addChildrenRecursively(node: Node): void { - function addChildrenRecursively(node: Node): void { - curCancellationToken.throwIfCancellationRequested(); + curCancellationToken.throwIfCancellationRequested(); - if (!node || isToken(node)) { - return; - } - - switch (node.kind) { - case SyntaxKind.Constructor: - // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it. - const ctr = node; - addNodeWithRecursiveChild(ctr, ctr.body, addChildrenRecursively); - - // Parameter properties are children of the class, not the constructor. - for (const param of ctr.parameters) { - if (isParameterPropertyDeclaration(param)) { - addLeafNode(param); - } - } - break; - - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.MethodSignature: - if (!hasDynamicName((node))) { - addNodeWithRecursiveChild(node, (node).body, addChildrenRecursively); - } - break; - - case SyntaxKind.PropertyDeclaration: - case SyntaxKind.PropertySignature: - if (!hasDynamicName((node))) { - addLeafNode(node); - } - break; - - case SyntaxKind.ImportClause: - const importClause = node; - // Handle default import case e.g.: - // import d from "mod"; - if (importClause.name) { - addLeafNode(importClause); - } - - // Handle named bindings in imports e.g.: - // import * as NS from "mod"; - // import {a, b as B} from "mod"; - const {namedBindings} = importClause; - if (namedBindings) { - if (namedBindings.kind === SyntaxKind.NamespaceImport) { - addLeafNode(namedBindings); - } - else { - for (const element of (namedBindings).elements) { - addLeafNode(element); - } - } - } - break; - - case SyntaxKind.BindingElement: - case SyntaxKind.VariableDeclaration: - const decl = node; - const name = decl.name; - if (isBindingPattern(name)) { - addChildrenRecursively(name); - } - else if (decl.initializer && isFunctionOrClassExpression(decl.initializer)) { - // For `const x = function() {}`, just use the function node, not the const. - addChildrenRecursively(decl.initializer); - } - else { - addNodeWithRecursiveChild(decl, decl.initializer, addChildrenRecursively); - } - break; - - case SyntaxKind.ArrowFunction: - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.FunctionExpression: - addNodeWithRecursiveChild(node, (node).body, addChildrenRecursively); - break; - - case SyntaxKind.EnumDeclaration: - startNode(node); - for (const member of (node).members) { - if (!isComputedProperty(member)) { - addLeafNode(member); - } - } - endNode(); - break; - - case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: - case SyntaxKind.InterfaceDeclaration: - startNode(node); - for (const member of (node).members) { - addChildrenRecursively(member); - } - endNode(); - break; - - case SyntaxKind.ModuleDeclaration: - addNodeWithRecursiveChild(node, getInteriorModule(node).body, addChildrenRecursively); - break; - - case SyntaxKind.ExportSpecifier: - case SyntaxKind.ImportEqualsDeclaration: - case SyntaxKind.IndexSignature: - case SyntaxKind.CallSignature: - case SyntaxKind.ConstructSignature: - case SyntaxKind.TypeAliasDeclaration: - addLeafNode(node); - break; - - default: - forEach(node.jsDoc, jsDoc => { - forEach(jsDoc.tags, tag => { - if (tag.kind === SyntaxKind.JSDocTypedefTag) { - addLeafNode(tag); - } - }); - }); - - forEachChild(node, addChildrenRecursively); - } + if (!node || isToken(node)) { + return; } - addChildrenRecursively(node); + switch (node.kind) { + case SyntaxKind.Constructor: + // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it. + const ctr = node; + addNodeWithRecursiveChild(ctr, ctr.body); + + // Parameter properties are children of the class, not the constructor. + for (const param of ctr.parameters) { + if (isParameterPropertyDeclaration(param)) { + addLeafNode(param); + } + } + break; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.MethodSignature: + if (!hasDynamicName((node))) { + addNodeWithRecursiveChild(node, (node).body); + } + break; + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.PropertySignature: + if (!hasDynamicName((node))) { + addLeafNode(node); + } + break; + + case SyntaxKind.ImportClause: + const importClause = node; + // Handle default import case e.g.: + // import d from "mod"; + if (importClause.name) { + addLeafNode(importClause); + } + + // Handle named bindings in imports e.g.: + // import * as NS from "mod"; + // import {a, b as B} from "mod"; + const {namedBindings} = importClause; + if (namedBindings) { + if (namedBindings.kind === SyntaxKind.NamespaceImport) { + addLeafNode(namedBindings); + } + else { + for (const element of (namedBindings).elements) { + addLeafNode(element); + } + } + } + break; + + case SyntaxKind.BindingElement: + case SyntaxKind.VariableDeclaration: + const decl = node; + const name = decl.name; + if (isBindingPattern(name)) { + addChildrenRecursively(name); + } + else if (decl.initializer && isFunctionOrClassExpression(decl.initializer)) { + // For `const x = function() {}`, just use the function node, not the const. + addChildrenRecursively(decl.initializer); + } + else { + addNodeWithRecursiveChild(decl, decl.initializer); + } + break; + + case SyntaxKind.ArrowFunction: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + addNodeWithRecursiveChild(node, (node).body); + break; + + case SyntaxKind.EnumDeclaration: + startNode(node); + for (const member of (node).members) { + if (!isComputedProperty(member)) { + addLeafNode(member); + } + } + endNode(); + break; + + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + case SyntaxKind.InterfaceDeclaration: + startNode(node); + for (const member of (node).members) { + addChildrenRecursively(member); + } + endNode(); + break; + + case SyntaxKind.ModuleDeclaration: + addNodeWithRecursiveChild(node, getInteriorModule(node).body); + break; + + case SyntaxKind.ExportSpecifier: + case SyntaxKind.ImportEqualsDeclaration: + case SyntaxKind.IndexSignature: + case SyntaxKind.CallSignature: + case SyntaxKind.ConstructSignature: + case SyntaxKind.TypeAliasDeclaration: + addLeafNode(node); + break; + + default: + forEach(node.jsDoc, jsDoc => { + forEach(jsDoc.tags, tag => { + if (tag.kind === SyntaxKind.JSDocTypedefTag) { + addLeafNode(tag); + } + }); + }); + + forEachChild(node, addChildrenRecursively); + } } /** Merge declarations of the same kind. */ diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 1b7618c0327..96a7c9a3c4a 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -1,6 +1,6 @@ /* @internal */ namespace ts.OutliningElementsCollector { - export function collectElements(sourceFile: SourceFile, cancellationToken: ThrottledCancellationToken): OutliningSpan[] { + export function collectElements(sourceFile: SourceFile, cancellationToken: CancellationToken): OutliningSpan[] { const elements: OutliningSpan[] = []; const collapseText = "..."; diff --git a/src/services/services.ts b/src/services/services.ts index 6cf50940fb7..cef307eb8fd 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -958,12 +958,7 @@ namespace ts { } class CancellationTokenObject implements CancellationToken { - throttleWaitMilliseconds?: number; - constructor(private cancellationToken: HostCancellationToken) { - if (cancellationToken.throttleWaitMilliseconds !== undefined) { - this.throttleWaitMilliseconds = cancellationToken.throttleWaitMilliseconds; - } } public isCancellationRequested() { @@ -977,42 +972,6 @@ namespace ts { } } - /** A cancellation that throttles calls to the host */ - export class ThrottledCancellationToken implements CancellationToken { - // Store when we last tried to cancel. Checking cancellation can be expensive (as we have - // to marshall over to the host layer). So we only bother actually checking once enough - // time has passed. - private lastCancellationCheckTime = 0; - // The minuimum duration to wait in milliseconds before querying host. - // The default of 10 milliseconds will be used unless throttleWaitMilliseconds - // is specified in the host cancellation token. - throttleWaitMilliseconds: number = 10; - - constructor(private hostCancellationToken: HostCancellationToken) { - if (hostCancellationToken.throttleWaitMilliseconds !== undefined) { - this.throttleWaitMilliseconds = hostCancellationToken.throttleWaitMilliseconds; - } - } - - public isCancellationRequested(): boolean { - const time = timestamp(); - const duration = Math.abs(time - this.lastCancellationCheckTime); - if (duration >= this.throttleWaitMilliseconds) { - // Check no more than the min wait in milliseconds - this.lastCancellationCheckTime = time; - return this.hostCancellationToken.isCancellationRequested(); - } - - return false; - } - - public throwIfCancellationRequested(): void { - if (this.isCancellationRequested()) { - throw new OperationCanceledException(); - } - } - } - export function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory())): LanguageService { @@ -1025,7 +984,6 @@ namespace ts { const useCaseSensitivefileNames = host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(); const cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken()); - const throttledCancellationToken = new ThrottledCancellationToken(cancellationToken); const currentDirectory = host.getCurrentDirectory(); // Check if the localized messages json is set, otherwise query the host for it @@ -1583,11 +1541,11 @@ namespace ts { } function getNavigationBarItems(fileName: string): NavigationBarItem[] { - return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), throttledCancellationToken); + return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); } function getNavigationTree(fileName: string): NavigationTree { - return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), throttledCancellationToken); + return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); } function isTsOrTsxFile(fileName: string): boolean { @@ -1626,7 +1584,7 @@ namespace ts { function getOutliningSpans(fileName: string): OutliningSpan[] { // doesn't use compiler - no need to synchronize with host const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return OutliningElementsCollector.collectElements(sourceFile, throttledCancellationToken); + return OutliningElementsCollector.collectElements(sourceFile, cancellationToken); } function getBraceMatchingAtPosition(fileName: string, position: number) { diff --git a/src/services/shims.ts b/src/services/shims.ts index de2fd39b8a8..6fe9aed144e 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -469,6 +469,29 @@ namespace ts { } } + /** A cancellation that throttles calls to the host */ + class ThrottledCancellationToken implements HostCancellationToken { + // Store when we last tried to cancel. Checking cancellation can be expensive (as we have + // to marshall over to the host layer). So we only bother actually checking once enough + // time has passed. + private lastCancellationCheckTime = 0; + + constructor(private hostCancellationToken: HostCancellationToken) { + } + + public isCancellationRequested(): boolean { + const time = timestamp(); + const duration = Math.abs(time - this.lastCancellationCheckTime); + if (duration > 10) { + // Check no more than once every 10 ms. + this.lastCancellationCheckTime = time; + return this.hostCancellationToken.isCancellationRequested(); + } + + return false; + } + } + export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost { public directoryExists: (directoryName: string) => boolean; diff --git a/src/services/types.ts b/src/services/types.ts index f9c33e15dfe..a6ca3852597 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -121,7 +121,6 @@ namespace ts { export interface HostCancellationToken { isCancellationRequested(): boolean; - throttleWaitMilliseconds?: number; } // From eca4af5029312493de84907830507dc119a57360 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Thu, 23 Feb 2017 15:26:30 -0800 Subject: [PATCH 012/218] When making unit test only include non empty line. This is crucial because it will allow us to test shebang which has to be the first line --- src/harness/harness.ts | 2 +- .../baselines/reference/APISample_compile.js | 1 - tests/baselines/reference/APISample_linter.js | 1 - .../reference/APISample_parseConfig.js | 1 - .../reference/APISample_transform.js | 1 - .../baselines/reference/APISample_watcher.js | 1 - .../DeclarationErrorsNoEmitOnError.errors.txt | 3 +- tests/baselines/reference/ES5for-of32.js | 1 - tests/baselines/reference/ES5for-of32.symbols | 17 +- tests/baselines/reference/ES5for-of32.types | 1 - ...itializedExportInInternalModule.errors.txt | 7 +- .../NonInitializedExportInInternalModule.js | 1 - .../reference/VariableDeclaration12_es6.js | 1 - .../VariableDeclaration12_es6.symbols | 3 +- .../reference/VariableDeclaration12_es6.types | 1 - .../VariableDeclaration13_es6.errors.txt | 9 +- .../reference/VariableDeclaration13_es6.js | 1 - .../abstractInterfaceIdentifierName.js | 1 - .../abstractInterfaceIdentifierName.symbols | 3 +- .../abstractInterfaceIdentifierName.types | 1 - .../accessibilityModifiers.errors.txt | 15 +- .../reference/accessibilityModifiers.js | 1 - ...rParameterAccessibilityModifier.errors.txt | 5 +- .../accessorParameterAccessibilityModifier.js | 1 - .../reference/accessorWithES3.errors.txt | 9 +- tests/baselines/reference/accessorWithES3.js | 1 - tests/baselines/reference/accessorWithES5.js | 1 - .../reference/accessorWithES5.symbols | 19 +- .../baselines/reference/accessorWithES5.types | 1 - .../accessorWithInitializer.errors.txt | 5 +- .../reference/accessorWithInitializer.js | 1 - ...ismatchedAccessibilityModifiers.errors.txt | 17 +- ...sorWithMismatchedAccessibilityModifiers.js | 1 - .../accessorWithRestParam.errors.txt | 5 +- .../reference/accessorWithRestParam.js | 1 - .../accessorsInAmbientContext.errors.txt | 9 +- .../reference/accessorsInAmbientContext.js | 1 - .../accessorsNotAllowedInES3.errors.txt | 5 +- .../reference/accessorsNotAllowedInES3.js | 1 - tests/baselines/reference/aliasBug.errors.txt | 3 +- tests/baselines/reference/aliasBug.js | 1 - .../aliasesInSystemModule1.errors.txt | 3 +- .../reference/aliasesInSystemModule1.js | 1 - .../aliasesInSystemModule2.errors.txt | 3 +- .../reference/aliasesInSystemModule2.js | 1 - .../reference/alwaysStrict.errors.txt | 3 +- tests/baselines/reference/alwaysStrict.js | 1 - .../reference/alwaysStrictES6.errors.txt | 3 +- tests/baselines/reference/alwaysStrictES6.js | 1 - .../reference/alwaysStrictModule.errors.txt | 3 +- .../baselines/reference/alwaysStrictModule.js | 1 - .../reference/alwaysStrictModule2.errors.txt | 3 +- .../reference/alwaysStrictModule2.js | 1 - .../reference/alwaysStrictModule3.js | 2 +- .../reference/alwaysStrictModule3.symbols | 3 +- .../reference/alwaysStrictModule3.types | 1 - .../reference/alwaysStrictModule4.js | 1 - .../reference/alwaysStrictModule4.symbols | 3 +- .../reference/alwaysStrictModule4.types | 1 - .../reference/alwaysStrictModule5.js | 2 +- .../reference/alwaysStrictModule5.symbols | 3 +- .../reference/alwaysStrictModule5.types | 1 - .../reference/alwaysStrictModule6.js | 1 - .../reference/alwaysStrictModule6.symbols | 3 +- .../reference/alwaysStrictModule6.types | 1 - ...alwaysStrictNoImplicitUseStrict.errors.txt | 3 +- .../alwaysStrictNoImplicitUseStrict.js | 1 - .../ambientClassDeclarationWithExtends.js | 2 - ...ambientClassDeclarationWithExtends.symbols | 14 +- .../ambientClassDeclarationWithExtends.types | 2 - .../ambientClassDeclaredBeforeBase.symbols | 7 +- .../ambientClassDeclaredBeforeBase.types | 1 - .../reference/ambientConstLiterals.js | 1 - .../reference/ambientConstLiterals.symbols | 59 +- .../reference/ambientConstLiterals.types | 1 - .../reference/ambientDeclarationsExternal.js | 1 - .../ambientDeclarationsExternal.symbols | 11 +- .../ambientDeclarationsExternal.types | 1 - ...alModuleInAnotherExternalModule.errors.txt | 5 +- ...ntExternalModuleInAnotherExternalModule.js | 1 - .../reference/ambientGetters.errors.txt | 5 +- tests/baselines/reference/ambientGetters.js | 1 - .../reference/ambientRequireFunction.js | 2 - .../reference/ambientRequireFunction.symbols | 14 +- .../reference/ambientRequireFunction.types | 2 - .../argumentsObjectIterator01_ES5.errors.txt | 3 +- .../argumentsObjectIterator01_ES5.js | 1 - .../argumentsObjectIterator01_ES6.js | 1 - .../argumentsObjectIterator01_ES6.symbols | 19 +- .../argumentsObjectIterator01_ES6.types | 1 - .../argumentsObjectIterator02_ES5.errors.txt | 3 +- .../argumentsObjectIterator02_ES5.js | 1 - .../argumentsObjectIterator02_ES6.js | 1 - .../argumentsObjectIterator02_ES6.symbols | 23 +- .../argumentsObjectIterator02_ES6.types | 1 - .../argumentsObjectIterator03_ES5.errors.txt | 3 +- .../argumentsObjectIterator03_ES5.js | 1 - .../argumentsObjectIterator03_ES6.js | 1 - .../argumentsObjectIterator03_ES6.symbols | 19 +- .../argumentsObjectIterator03_ES6.types | 1 - .../reference/arrayAssignmentTest4.errors.txt | 6 +- .../reference/arrayAssignmentTest4.js | 2 - .../arrayBindingPatternOmittedExpressions.js | 1 - ...ayBindingPatternOmittedExpressions.symbols | 33 +- ...rrayBindingPatternOmittedExpressions.types | 1 - .../arrowFunctionContexts.errors.txt | 21 +- .../reference/arrowFunctionContexts.js | 1 - ...owFunctionWithParameterNameAsync_es2017.js | 1 - ...ctionWithParameterNameAsync_es2017.symbols | 7 +- ...unctionWithParameterNameAsync_es2017.types | 1 - ...arrowFunctionWithParameterNameAsync_es5.js | 1 - ...FunctionWithParameterNameAsync_es5.symbols | 7 +- ...owFunctionWithParameterNameAsync_es5.types | 1 - ...arrowFunctionWithParameterNameAsync_es6.js | 1 - ...FunctionWithParameterNameAsync_es6.symbols | 7 +- ...owFunctionWithParameterNameAsync_es6.types | 1 - .../arrowFunctionsMissingTokens.errors.txt | 49 +- .../reference/arrowFunctionsMissingTokens.js | 1 - tests/baselines/reference/asOperator4.js | 1 - tests/baselines/reference/asOperator4.symbols | 1 - tests/baselines/reference/asOperator4.types | 1 - ...reventsParsingAsAmbientExternalModule01.js | 1 - ...tsParsingAsAmbientExternalModule01.symbols | 9 +- ...entsParsingAsAmbientExternalModule01.types | 1 - ...reventsParsingAsAmbientExternalModule02.js | 1 - ...tsParsingAsAmbientExternalModule02.symbols | 11 +- ...entsParsingAsAmbientExternalModule02.types | 1 - .../asiPreventsParsingAsInterface01.js | 1 - .../asiPreventsParsingAsInterface01.symbols | 9 +- .../asiPreventsParsingAsInterface01.types | 1 - .../asiPreventsParsingAsInterface02.js | 1 - .../asiPreventsParsingAsInterface02.symbols | 9 +- .../asiPreventsParsingAsInterface02.types | 1 - .../asiPreventsParsingAsInterface03.js | 1 - .../asiPreventsParsingAsInterface03.symbols | 11 +- .../asiPreventsParsingAsInterface03.types | 1 - .../asiPreventsParsingAsInterface04.js | 1 - .../asiPreventsParsingAsInterface04.symbols | 13 +- .../asiPreventsParsingAsInterface04.types | 1 - .../asiPreventsParsingAsNamespace01.js | 1 - .../asiPreventsParsingAsNamespace01.symbols | 9 +- .../asiPreventsParsingAsNamespace01.types | 1 - .../asiPreventsParsingAsNamespace02.js | 1 - .../asiPreventsParsingAsNamespace02.symbols | 9 +- .../asiPreventsParsingAsNamespace02.types | 1 - .../asiPreventsParsingAsNamespace03.js | 1 - .../asiPreventsParsingAsNamespace03.symbols | 11 +- .../asiPreventsParsingAsNamespace03.types | 1 - .../asiPreventsParsingAsNamespace04.js | 1 - .../asiPreventsParsingAsNamespace04.symbols | 5 +- .../asiPreventsParsingAsNamespace04.types | 1 - .../asiPreventsParsingAsNamespace05.js | 1 - .../asiPreventsParsingAsNamespace05.symbols | 21 +- .../asiPreventsParsingAsNamespace05.types | 1 - .../asiPreventsParsingAsTypeAlias01.js | 1 - .../asiPreventsParsingAsTypeAlias01.symbols | 13 +- .../asiPreventsParsingAsTypeAlias01.types | 1 - .../asiPreventsParsingAsTypeAlias02.js | 1 - .../asiPreventsParsingAsTypeAlias02.symbols | 15 +- .../asiPreventsParsingAsTypeAlias02.types | 1 - .../asyncArrowFunction10_es2017.errors.txt | 3 +- .../reference/asyncArrowFunction10_es2017.js | 1 - .../asyncArrowFunction10_es5.errors.txt | 3 +- .../reference/asyncArrowFunction10_es5.js | 1 - .../asyncArrowFunction10_es6.errors.txt | 3 +- .../reference/asyncArrowFunction10_es6.js | 1 - .../reference/asyncArrowFunction1_es2017.js | 1 - .../asyncArrowFunction1_es2017.symbols | 3 +- .../asyncArrowFunction1_es2017.types | 1 - .../reference/asyncArrowFunction1_es5.js | 1 - .../reference/asyncArrowFunction1_es5.symbols | 3 +- .../reference/asyncArrowFunction1_es5.types | 1 - .../reference/asyncArrowFunction1_es6.js | 1 - .../reference/asyncArrowFunction1_es6.symbols | 3 +- .../reference/asyncArrowFunction1_es6.types | 1 - .../asyncArrowFunction5_es2017.errors.txt | 13 +- .../reference/asyncArrowFunction5_es2017.js | 1 - .../asyncArrowFunction5_es5.errors.txt | 13 +- .../reference/asyncArrowFunction5_es5.js | 1 - .../asyncArrowFunction5_es6.errors.txt | 13 +- .../reference/asyncArrowFunction5_es6.js | 1 - .../asyncArrowFunction6_es2017.errors.txt | 5 +- .../reference/asyncArrowFunction6_es2017.js | 1 - .../asyncArrowFunction6_es5.errors.txt | 5 +- .../reference/asyncArrowFunction6_es5.js | 1 - .../asyncArrowFunction6_es6.errors.txt | 5 +- .../reference/asyncArrowFunction6_es6.js | 1 - .../asyncArrowFunction7_es2017.errors.txt | 5 +- .../reference/asyncArrowFunction7_es2017.js | 1 - .../asyncArrowFunction7_es5.errors.txt | 5 +- .../reference/asyncArrowFunction7_es5.js | 1 - .../asyncArrowFunction7_es6.errors.txt | 5 +- .../reference/asyncArrowFunction7_es6.js | 1 - .../asyncArrowFunction8_es2017.errors.txt | 3 +- .../reference/asyncArrowFunction8_es2017.js | 1 - .../asyncArrowFunction8_es5.errors.txt | 3 +- .../reference/asyncArrowFunction8_es5.js | 1 - .../asyncArrowFunction8_es6.errors.txt | 3 +- .../reference/asyncArrowFunction8_es6.js | 1 - .../asyncFunctionsAndStrictNullChecks.js | 1 - .../asyncFunctionsAndStrictNullChecks.symbols | 145 +- .../asyncFunctionsAndStrictNullChecks.types | 1 - tests/baselines/reference/asyncIIFE.js | 1 - tests/baselines/reference/asyncIIFE.symbols | 3 +- tests/baselines/reference/asyncIIFE.types | 1 - ...syncUnParenthesizedArrowFunction_es2017.js | 1 - ...nParenthesizedArrowFunction_es2017.symbols | 15 +- ...cUnParenthesizedArrowFunction_es2017.types | 1 - .../asyncUnParenthesizedArrowFunction_es5.js | 1 - ...ncUnParenthesizedArrowFunction_es5.symbols | 15 +- ...syncUnParenthesizedArrowFunction_es5.types | 1 - .../asyncUnParenthesizedArrowFunction_es6.js | 1 - ...ncUnParenthesizedArrowFunction_es6.symbols | 15 +- ...syncUnParenthesizedArrowFunction_es6.types | 1 - .../reference/augmentExportEquals1.errors.txt | 3 +- .../reference/augmentExportEquals1.js | 1 - .../augmentExportEquals1_1.errors.txt | 1 - .../reference/augmentExportEquals1_1.js | 1 - .../reference/augmentExportEquals2.errors.txt | 1 - .../reference/augmentExportEquals2.js | 1 - .../augmentExportEquals2_1.errors.txt | 4 +- .../reference/augmentExportEquals2_1.js | 2 - .../reference/augmentExportEquals3.js | 1 - .../reference/augmentExportEquals3.symbols | 9 +- .../reference/augmentExportEquals3.types | 1 - .../reference/augmentExportEquals4.js | 1 - .../reference/augmentExportEquals4.symbols | 9 +- .../reference/augmentExportEquals4.types | 1 - .../reference/augmentExportEquals4_1.js | 1 - .../reference/augmentExportEquals4_1.symbols | 9 +- .../reference/augmentExportEquals4_1.types | 1 - .../reference/augmentExportEquals5.js | 2 - .../reference/augmentExportEquals5.symbols | 154 +- .../reference/augmentExportEquals5.types | 2 - .../reference/augmentExportEquals6.js | 1 - .../reference/augmentExportEquals6.symbols | 27 +- .../reference/augmentExportEquals6.types | 1 - .../reference/augmentExportEquals6_1.js | 1 - .../reference/augmentExportEquals6_1.symbols | 13 +- .../reference/augmentExportEquals6_1.types | 1 - .../reference/await_unaryExpression_es2017.js | 1 - .../await_unaryExpression_es2017.symbols | 7 +- .../await_unaryExpression_es2017.types | 1 - .../await_unaryExpression_es2017_1.errors.txt | 5 +- .../await_unaryExpression_es2017_1.js | 1 - .../await_unaryExpression_es2017_2.errors.txt | 5 +- .../await_unaryExpression_es2017_2.js | 1 - .../await_unaryExpression_es2017_3.errors.txt | 5 +- .../await_unaryExpression_es2017_3.js | 1 - .../reference/await_unaryExpression_es6.js | 1 - .../await_unaryExpression_es6.symbols | 7 +- .../reference/await_unaryExpression_es6.types | 1 - .../await_unaryExpression_es6_1.errors.txt | 5 +- .../reference/await_unaryExpression_es6_1.js | 1 - .../await_unaryExpression_es6_2.errors.txt | 5 +- .../reference/await_unaryExpression_es6_2.js | 1 - .../await_unaryExpression_es6_3.errors.txt | 5 +- .../reference/await_unaryExpression_es6_3.js | 1 - tests/baselines/reference/bangInModuleName.js | 3 - .../reference/bangInModuleName.symbols | 9 +- .../reference/bangInModuleName.types | 3 - tests/baselines/reference/bestChoiceType.js | 1 - .../reference/bestChoiceType.symbols | 39 +- .../baselines/reference/bestChoiceType.types | 1 - .../bestCommonTypeReturnStatement.js | 1 - .../bestCommonTypeReturnStatement.symbols | 25 +- .../bestCommonTypeReturnStatement.types | 1 - ...wiseNotOperatorWithAnyOtherType.errors.txt | 15 +- .../bitwiseNotOperatorWithAnyOtherType.js | 1 - .../bitwiseNotOperatorWithBooleanType.js | 1 - .../bitwiseNotOperatorWithBooleanType.symbols | 79 +- .../bitwiseNotOperatorWithBooleanType.types | 1 - .../bitwiseNotOperatorWithEnumType.js | 1 - .../bitwiseNotOperatorWithEnumType.symbols | 35 +- .../bitwiseNotOperatorWithEnumType.types | 1 - .../bitwiseNotOperatorWithNumberType.js | 1 - .../bitwiseNotOperatorWithNumberType.symbols | 125 +- .../bitwiseNotOperatorWithNumberType.types | 1 - .../bitwiseNotOperatorWithStringType.js | 1 - .../bitwiseNotOperatorWithStringType.symbols | 117 +- .../bitwiseNotOperatorWithStringType.types | 1 - .../blockScopedBindingsReassignedInLoop3.js | 1 - ...ockScopedBindingsReassignedInLoop3.symbols | 161 +- ...blockScopedBindingsReassignedInLoop3.types | 1 - .../reference/booleanLiteralTypes2.js | 1 - .../reference/booleanLiteralTypes2.symbols | 221 +- .../reference/booleanLiteralTypes2.types | 1 - tests/baselines/reference/breakTarget3.js | 1 - .../baselines/reference/breakTarget3.symbols | 3 +- tests/baselines/reference/breakTarget3.types | 1 - tests/baselines/reference/breakTarget4.js | 1 - .../baselines/reference/breakTarget4.symbols | 3 +- tests/baselines/reference/breakTarget4.types | 1 - .../reference/breakTarget5.errors.txt | 3 +- tests/baselines/reference/breakTarget5.js | 1 - tests/baselines/reference/cacheResolutions.js | 1 - .../reference/cacheResolutions.symbols | 3 +- .../reference/cacheResolutions.types | 1 - .../reference/cachedModuleResolution1.js | 1 - .../reference/cachedModuleResolution1.symbols | 3 +- .../reference/cachedModuleResolution1.types | 1 - .../reference/cachedModuleResolution2.js | 1 - .../reference/cachedModuleResolution2.symbols | 3 +- .../reference/cachedModuleResolution2.types | 1 - .../reference/cachedModuleResolution3.js | 1 - .../reference/cachedModuleResolution3.symbols | 3 +- .../reference/cachedModuleResolution3.types | 1 - .../reference/cachedModuleResolution4.js | 1 - .../reference/cachedModuleResolution4.symbols | 3 +- .../reference/cachedModuleResolution4.types | 1 - .../reference/cachedModuleResolution5.js | 1 - .../reference/cachedModuleResolution5.symbols | 3 +- .../reference/cachedModuleResolution5.types | 1 - .../cachedModuleResolution6.errors.txt | 3 +- .../reference/cachedModuleResolution6.js | 1 - .../cachedModuleResolution7.errors.txt | 3 +- .../reference/cachedModuleResolution7.js | 1 - .../cachedModuleResolution8.errors.txt | 3 +- .../reference/cachedModuleResolution8.js | 1 - .../cachedModuleResolution9.errors.txt | 3 +- .../reference/cachedModuleResolution9.js | 1 - .../callConstructAssignment.errors.txt | 6 +- .../reference/callConstructAssignment.js | 2 - .../reference/callOverloads2.errors.txt | 16 +- tests/baselines/reference/callOverloads2.js | 2 - .../reference/callOverloads3.errors.txt | 13 +- tests/baselines/reference/callOverloads3.js | 1 - .../reference/callOverloads4.errors.txt | 13 +- tests/baselines/reference/callOverloads4.js | 1 - ...ureWithoutReturnTypeAnnotationInference.js | 1 - ...thoutReturnTypeAnnotationInference.symbols | 197 +- ...WithoutReturnTypeAnnotationInference.types | 1 - .../baselines/reference/callWithSpreadES6.js | 1 - .../reference/callWithSpreadES6.symbols | 171 +- .../reference/callWithSpreadES6.types | 1 - .../reference/capturedLetConstInLoop2.js | 2 - .../reference/capturedLetConstInLoop2.symbols | 392 +- .../reference/capturedLetConstInLoop2.types | 2 - .../reference/capturedLetConstInLoop2_ES6.js | 1 - .../capturedLetConstInLoop2_ES6.symbols | 391 +- .../capturedLetConstInLoop2_ES6.types | 1 - .../reference/capturedLetConstInLoop3_ES6.js | 1 - .../capturedLetConstInLoop3_ES6.symbols | 475 ++- .../capturedLetConstInLoop3_ES6.types | 1 - .../reference/capturedLetConstInLoop4.js | 1 - .../reference/capturedLetConstInLoop4.symbols | 359 +- .../reference/capturedLetConstInLoop4.types | 1 - .../reference/capturedLetConstInLoop4_ES6.js | 2 +- .../capturedLetConstInLoop4_ES6.symbols | 359 +- .../capturedLetConstInLoop4_ES6.types | 1 - .../capturedLetConstInLoop5_ES6.errors.txt | 5 +- .../reference/capturedLetConstInLoop5_ES6.js | 1 - .../reference/capturedLetConstInLoop9_ES6.js | 1 - .../capturedLetConstInLoop9_ES6.symbols | 153 +- .../capturedLetConstInLoop9_ES6.types | 1 - tests/baselines/reference/castTest.js | 1 - tests/baselines/reference/castTest.symbols | 77 +- tests/baselines/reference/castTest.types | 1 - .../circularIndexedAccessErrors.errors.txt | 13 +- .../reference/circularIndexedAccessErrors.js | 1 - .../circularObjectLiteralAccessors.js | 1 - .../circularObjectLiteralAccessors.symbols | 27 +- .../circularObjectLiteralAccessors.types | 1 - .../reference/circularReferenceInImport.js | 1 - .../circularReferenceInImport.symbols | 3 +- .../reference/circularReferenceInImport.types | 1 - .../classAbstractAccessor.errors.txt | 5 +- .../reference/classAbstractAccessor.js | 1 - ...bstractConstructorAssignability.errors.txt | 7 +- .../classAbstractConstructorAssignability.js | 1 - .../reference/classAbstractExtends.errors.txt | 3 +- .../reference/classAbstractExtends.js | 1 - .../classAbstractFactoryFunction.errors.txt | 5 +- .../reference/classAbstractFactoryFunction.js | 1 - .../classAbstractInstantiations1.errors.txt | 5 +- .../reference/classAbstractInstantiations1.js | 1 - .../classAbstractSuperCalls.errors.txt | 5 +- .../reference/classAbstractSuperCalls.js | 1 - .../classAndInterfaceMerge.d.symbols | 25 +- .../reference/classAndInterfaceMerge.d.types | 1 - .../classConstructorAccessibility.errors.txt | 9 +- .../classConstructorAccessibility.js | 1 - .../classConstructorAccessibility2.errors.txt | 11 +- .../classConstructorAccessibility2.js | 1 - .../classConstructorAccessibility3.errors.txt | 7 +- .../classConstructorAccessibility3.js | 1 - .../classConstructorAccessibility4.js | 1 - .../classConstructorAccessibility4.symbols | 23 +- .../classConstructorAccessibility4.types | 1 - ...nstructorOverloadsAccessibility.errors.txt | 5 +- .../classConstructorOverloadsAccessibility.js | 1 - .../classExpressionWithStaticProperties3.js | 1 - ...assExpressionWithStaticProperties3.symbols | 41 +- ...classExpressionWithStaticProperties3.types | 1 - ...classExpressionWithStaticPropertiesES63.js | 1 - ...ExpressionWithStaticPropertiesES63.symbols | 41 +- ...ssExpressionWithStaticPropertiesES63.types | 1 - .../reference/classOrder2.errors.txt | 3 +- tests/baselines/reference/classOrder2.js | 1 - .../reference/classStaticPropertyTypeGuard.js | 1 - .../classStaticPropertyTypeGuard.symbols | 17 +- .../classStaticPropertyTypeGuard.types | 1 - ...maOperatorInvalidAssignmentType.errors.txt | 13 +- .../commaOperatorInvalidAssignmentType.js | 1 - ...maOperatorOtherInvalidOperation.errors.txt | 5 +- .../commaOperatorOtherInvalidOperation.js | 1 - .../commaOperatorOtherValidOperation.js | 1 - .../commaOperatorOtherValidOperation.symbols | 51 +- .../commaOperatorOtherValidOperation.types | 1 - .../commaOperatorWithSecondOperandAnyType.js | 1 - ...maOperatorWithSecondOperandAnyType.symbols | 99 +- ...ommaOperatorWithSecondOperandAnyType.types | 1 - ...mmaOperatorWithSecondOperandBooleanType.js | 1 - ...eratorWithSecondOperandBooleanType.symbols | 101 +- ...OperatorWithSecondOperandBooleanType.types | 1 - ...ommaOperatorWithSecondOperandNumberType.js | 1 - ...peratorWithSecondOperandNumberType.symbols | 101 +- ...aOperatorWithSecondOperandNumberType.types | 1 - ...ommaOperatorWithSecondOperandObjectType.js | 1 - ...peratorWithSecondOperandObjectType.symbols | 105 +- ...aOperatorWithSecondOperandObjectType.types | 1 - ...ommaOperatorWithSecondOperandStringType.js | 1 - ...peratorWithSecondOperandStringType.symbols | 101 +- ...aOperatorWithSecondOperandStringType.types | 1 - .../commaOperatorsMultipleOperators.js | 1 - .../commaOperatorsMultipleOperators.symbols | 93 +- .../commaOperatorsMultipleOperators.types | 1 - .../reference/commentEmitAtEndOfFile1.js | 1 - .../reference/commentEmitAtEndOfFile1.symbols | 9 +- .../reference/commentEmitAtEndOfFile1.types | 1 - .../commentOnExpressionStatement1.js | 1 - .../commentOnExpressionStatement1.symbols | 3 +- .../commentOnExpressionStatement1.types | 1 - .../reference/commentOnIfStatement1.js | 1 - .../reference/commentOnIfStatement1.symbols | 3 +- .../reference/commentOnIfStatement1.types | 1 - .../reference/commentsAtEndOfFile1.js | 1 - .../reference/commentsAtEndOfFile1.symbols | 3 +- .../reference/commentsAtEndOfFile1.types | 1 - tests/baselines/reference/commentsClass.js | 1 - .../baselines/reference/commentsClass.symbols | 75 +- tests/baselines/reference/commentsClass.types | 1 - .../reference/commentsClassMembers.js | 1 - .../reference/commentsClassMembers.symbols | 653 ++-- .../reference/commentsClassMembers.types | 1 - .../reference/commentsCommentParsing.js | 1 - .../reference/commentsCommentParsing.symbols | 141 +- .../reference/commentsCommentParsing.types | 1 - .../reference/commentsDottedModuleName.js | 1 - .../commentsDottedModuleName.symbols | 5 +- .../reference/commentsDottedModuleName.types | 1 - tests/baselines/reference/commentsEnums.js | 1 - .../baselines/reference/commentsEnums.symbols | 17 +- tests/baselines/reference/commentsEnums.types | 1 - .../reference/commentsExternalModules.js | 1 - .../reference/commentsExternalModules.symbols | 103 +- .../reference/commentsExternalModules.types | 1 - .../reference/commentsExternalModules2.js | 1 - .../commentsExternalModules2.symbols | 103 +- .../reference/commentsExternalModules2.types | 1 - .../reference/commentsExternalModules3.js | 1 - .../commentsExternalModules3.symbols | 103 +- .../reference/commentsExternalModules3.types | 1 - .../baselines/reference/commentsFormatting.js | 1 - .../reference/commentsFormatting.symbols | 9 +- .../reference/commentsFormatting.types | 1 - tests/baselines/reference/commentsFunction.js | 1 - .../reference/commentsFunction.symbols | 77 +- .../reference/commentsFunction.types | 1 - .../reference/commentsInheritance.js | 1 - .../reference/commentsInheritance.symbols | 189 +- .../reference/commentsInheritance.types | 1 - .../reference/commentsMultiModuleMultiFile.js | 1 - .../commentsMultiModuleMultiFile.symbols | 23 +- .../commentsMultiModuleMultiFile.types | 1 - .../commentsMultiModuleSingleFile.js | 1 - .../commentsMultiModuleSingleFile.symbols | 25 +- .../commentsMultiModuleSingleFile.types | 1 - .../reference/commentsOnObjectLiteral3.js | 1 - .../commentsOnObjectLiteral3.symbols | 17 +- .../reference/commentsOnObjectLiteral3.types | 1 - .../reference/commentsOnObjectLiteral4.js | 1 - .../commentsOnObjectLiteral4.symbols | 5 +- .../reference/commentsOnObjectLiteral4.types | 1 - .../reference/commentsOnRequireStatement.js | 1 - .../commentsOnRequireStatement.symbols | 3 +- .../commentsOnRequireStatement.types | 1 - .../reference/commentsOnStaticMembers.js | 1 - .../reference/commentsOnStaticMembers.symbols | 9 +- .../reference/commentsOnStaticMembers.types | 1 - tests/baselines/reference/commentsVarDecl.js | 1 - .../reference/commentsVarDecl.symbols | 47 +- .../baselines/reference/commentsVarDecl.types | 1 - .../reference/commentsVariableStatement1.js | 1 - .../commentsVariableStatement1.symbols | 3 +- .../commentsVariableStatement1.types | 1 - .../reference/commentsdoNotEmitComments.js | 1 - .../commentsdoNotEmitComments.symbols | 109 +- .../reference/commentsdoNotEmitComments.types | 1 - .../reference/commentsemitComments.js | 1 - .../reference/commentsemitComments.symbols | 91 +- .../reference/commentsemitComments.types | 1 - tests/baselines/reference/commonSourceDir5.js | 1 - .../reference/commonSourceDir5.symbols | 9 +- .../reference/commonSourceDir5.types | 1 - .../baselines/reference/commonjsSafeImport.js | 1 - .../reference/commonjsSafeImport.symbols | 1 - .../reference/commonjsSafeImport.types | 1 - ...ompilerOptionsDeclarationAndNoEmit.symbols | 1 - .../compilerOptionsDeclarationAndNoEmit.types | 1 - .../compilerOptionsOutAndNoEmit.symbols | 1 - .../compilerOptionsOutAndNoEmit.types | 1 - .../compilerOptionsOutDirAndNoEmit.symbols | 1 - .../compilerOptionsOutDirAndNoEmit.types | 1 - .../compilerOptionsOutFileAndNoEmit.symbols | 1 - .../compilerOptionsOutFileAndNoEmit.types | 1 - .../compoundAssignmentLHSIsValue.errors.txt | 107 +- .../reference/compoundAssignmentLHSIsValue.js | 1 - .../computedPropertiesInDestructuring2_ES6.js | 1 - ...utedPropertiesInDestructuring2_ES6.symbols | 7 +- ...mputedPropertiesInDestructuring2_ES6.types | 1 - .../computedPropertyNames49_ES5.errors.txt | 17 +- .../reference/computedPropertyNames49_ES5.js | 1 - .../computedPropertyNames49_ES6.errors.txt | 9 +- .../reference/computedPropertyNames49_ES6.js | 1 - .../computedPropertyNames50_ES5.errors.txt | 17 +- .../reference/computedPropertyNames50_ES5.js | 1 - .../computedPropertyNames50_ES6.errors.txt | 9 +- .../reference/computedPropertyNames50_ES6.js | 1 - tests/baselines/reference/concatError.js | 1 - tests/baselines/reference/concatError.symbols | 13 +- tests/baselines/reference/concatError.types | 1 - .../reference/conditionalExpressions2.js | 1 - .../reference/conditionalExpressions2.symbols | 25 +- .../reference/conditionalExpressions2.types | 1 - ...arationShadowedByVarDeclaration.errors.txt | 7 +- ...onstDeclarationShadowedByVarDeclaration.js | 1 - ...nstDeclarationShadowedByVarDeclaration2.js | 1 - ...clarationShadowedByVarDeclaration2.symbols | 7 +- ...DeclarationShadowedByVarDeclaration2.types | 1 - .../constDeclarations-access.errors.txt | 1 - .../reference/constDeclarations-access.js | 1 - .../constDeclarations-access2.errors.txt | 9 +- .../reference/constDeclarations-access2.js | 1 - .../constDeclarations-access3.errors.txt | 16 +- .../reference/constDeclarations-access3.js | 2 - .../constDeclarations-access4.errors.txt | 16 +- .../reference/constDeclarations-access4.js | 2 - .../constDeclarations-access5.errors.txt | 2 - .../reference/constDeclarations-access5.js | 2 - ...onstDeclarations-ambient-errors.errors.txt | 13 +- .../constDeclarations-ambient-errors.js | 1 - .../reference/constDeclarations-ambient.js | 1 - .../constDeclarations-ambient.symbols | 17 +- .../reference/constDeclarations-ambient.types | 1 - .../constDeclarations-errors.errors.txt | 15 +- .../reference/constDeclarations-errors.js | 1 - .../reference/constDeclarations-es5.js | 1 - .../reference/constDeclarations-es5.symbols | 11 +- .../reference/constDeclarations-es5.types | 1 - ...nstDeclarations-invalidContexts.errors.txt | 19 +- .../constDeclarations-invalidContexts.js | 1 - .../constDeclarations-scopes.errors.txt | 7 +- .../reference/constDeclarations-scopes.js | 1 - .../reference/constDeclarations-scopes2.js | 1 - .../constDeclarations-scopes2.symbols | 21 +- .../reference/constDeclarations-scopes2.types | 1 - ...eclarations-useBeforeDefinition.errors.txt | 5 +- .../constDeclarations-useBeforeDefinition.js | 1 - ...clarations-useBeforeDefinition2.errors.txt | 3 +- .../constDeclarations-useBeforeDefinition2.js | 1 - ...constDeclarations-validContexts.errors.txt | 4 +- .../constDeclarations-validContexts.js | 2 - .../baselines/reference/constDeclarations.js | 1 - .../reference/constDeclarations.symbols | 23 +- .../reference/constDeclarations.types | 1 - .../baselines/reference/constDeclarations2.js | 1 - .../reference/constDeclarations2.symbols | 11 +- .../reference/constDeclarations2.types | 1 - tests/baselines/reference/constEnum1.js | 1 - tests/baselines/reference/constEnum1.symbols | 31 +- tests/baselines/reference/constEnum1.types | 1 - .../baselines/reference/constEnum2.errors.txt | 5 +- tests/baselines/reference/constEnum2.js | 1 - .../reference/constEnumDeclarations.js | 1 - .../reference/constEnumDeclarations.symbols | 19 +- .../reference/constEnumDeclarations.types | 1 - .../reference/constEnumMergingWithValues1.js | 1 - .../constEnumMergingWithValues1.symbols | 11 +- .../constEnumMergingWithValues1.types | 1 - .../reference/constEnumMergingWithValues2.js | 1 - .../constEnumMergingWithValues2.symbols | 11 +- .../constEnumMergingWithValues2.types | 1 - .../reference/constEnumMergingWithValues3.js | 1 - .../constEnumMergingWithValues3.symbols | 13 +- .../constEnumMergingWithValues3.types | 1 - .../reference/constEnumMergingWithValues4.js | 1 - .../constEnumMergingWithValues4.symbols | 13 +- .../constEnumMergingWithValues4.types | 1 - .../reference/constEnumMergingWithValues5.js | 1 - .../constEnumMergingWithValues5.symbols | 5 +- .../constEnumMergingWithValues5.types | 1 - .../reference/constEnumPropertyAccess1.js | 1 - .../constEnumPropertyAccess1.symbols | 53 +- .../reference/constEnumPropertyAccess1.types | 1 - .../constEnumPropertyAccess2.errors.txt | 9 +- .../reference/constEnumPropertyAccess2.js | 1 - .../baselines/reference/constIndexedAccess.js | 1 - .../reference/constIndexedAccess.symbols | 77 +- .../reference/constIndexedAccess.types | 1 - ...constructableDecoratorOnClass01.errors.txt | 3 +- .../constructableDecoratorOnClass01.js | 1 - ...torWithIncompleteTypeAnnotation.errors.txt | 171 +- ...constructorWithIncompleteTypeAnnotation.js | 1 - .../contextuallyTypeCommaOperator01.js | 1 - .../contextuallyTypeCommaOperator01.symbols | 11 +- .../contextuallyTypeCommaOperator01.types | 1 - ...contextuallyTypeCommaOperator02.errors.txt | 5 +- .../contextuallyTypeCommaOperator02.js | 1 - ...contextuallyTypeCommaOperator03.errors.txt | 3 +- .../contextuallyTypeCommaOperator03.js | 1 - .../reference/contextuallyTypeLogicalAnd01.js | 1 - .../contextuallyTypeLogicalAnd01.symbols | 15 +- .../contextuallyTypeLogicalAnd01.types | 1 - .../contextuallyTypeLogicalAnd02.errors.txt | 5 +- .../reference/contextuallyTypeLogicalAnd02.js | 1 - .../contextuallyTypeLogicalAnd03.errors.txt | 3 +- .../reference/contextuallyTypeLogicalAnd03.js | 1 - ...ssExpressionMethodDeclaration01.errors.txt | 13 +- ...TypedClassExpressionMethodDeclaration01.js | 1 - ...ssExpressionMethodDeclaration02.errors.txt | 13 +- ...TypedClassExpressionMethodDeclaration02.js | 1 - ...lyTypedObjectLiteralMethodDeclaration01.js | 1 - ...edObjectLiteralMethodDeclaration01.symbols | 91 +- ...ypedObjectLiteralMethodDeclaration01.types | 1 - ...StringLiteralsInJsxAttributes01.errors.txt | 5 +- ...llyTypedStringLiteralsInJsxAttributes01.js | 1 - ...StringLiteralsInJsxAttributes02.errors.txt | 13 +- ...llyTypedStringLiteralsInJsxAttributes02.js | 1 - ...ontinueNotInIterationStatement4.errors.txt | 3 +- .../continueNotInIterationStatement4.js | 1 - tests/baselines/reference/continueTarget3.js | 1 - .../reference/continueTarget3.symbols | 3 +- .../baselines/reference/continueTarget3.types | 1 - tests/baselines/reference/continueTarget4.js | 1 - .../reference/continueTarget4.symbols | 3 +- .../baselines/reference/continueTarget4.types | 1 - .../reference/continueTarget5.errors.txt | 3 +- tests/baselines/reference/continueTarget5.js | 1 - .../controlFlowArrayErrors.errors.txt | 25 +- .../reference/controlFlowArrayErrors.js | 1 - .../baselines/reference/controlFlowArrays.js | 1 - .../reference/controlFlowArrays.symbols | 227 +- .../reference/controlFlowArrays.types | 1 - .../baselines/reference/controlFlowCaching.js | 1 - .../reference/controlFlowCaching.symbols | 291 +- .../reference/controlFlowCaching.types | 1 - .../controlFlowDeleteOperator.errors.txt | 3 +- .../reference/controlFlowDeleteOperator.js | 1 - .../controlFlowDestructuringDeclaration.js | 1 - ...ontrolFlowDestructuringDeclaration.symbols | 125 +- .../controlFlowDestructuringDeclaration.types | 1 - tests/baselines/reference/controlFlowIIFE.js | 1 - .../reference/controlFlowIIFE.symbols | 57 +- .../baselines/reference/controlFlowIIFE.types | 1 - .../reference/controlFlowIfStatement.js | 1 - .../reference/controlFlowIfStatement.symbols | 73 +- .../reference/controlFlowIfStatement.types | 1 - .../reference/controlFlowInstanceof.js | 1 - .../reference/controlFlowInstanceof.symbols | 157 +- .../reference/controlFlowInstanceof.types | 1 - .../reference/controlFlowIteration.js | 1 - .../reference/controlFlowIteration.symbols | 19 +- .../reference/controlFlowIteration.types | 1 - .../controlFlowIterationErrors.errors.txt | 17 +- .../reference/controlFlowIterationErrors.js | 1 - .../reference/controlFlowJavascript.js | 1 - .../reference/controlFlowJavascript.symbols | 143 +- .../reference/controlFlowJavascript.types | 1 - .../controlFlowLoopAnalysis.errors.txt | 3 +- .../reference/controlFlowLoopAnalysis.js | 1 - .../controlFlowNoImplicitAny.errors.txt | 9 +- .../reference/controlFlowNoImplicitAny.js | 1 - .../reference/controlFlowOuterVariable.js | 1 - .../controlFlowOuterVariable.symbols | 29 +- .../reference/controlFlowOuterVariable.types | 1 - .../controlFlowPropertyInitializer.js | 1 - .../controlFlowPropertyInitializer.symbols | 9 +- .../controlFlowPropertyInitializer.types | 1 - .../controlFlowSelfReferentialLoop.errors.txt | 57 +- .../controlFlowSelfReferentialLoop.js | 1 - .../reference/controlFlowTruthiness.js | 1 - .../reference/controlFlowTruthiness.symbols | 79 +- .../reference/controlFlowTruthiness.types | 1 - .../baselines/reference/declFileAccessors.js | 1 - .../reference/declFileAccessors.symbols | 43 +- .../reference/declFileAccessors.types | 1 - .../declFileAliasUseBeforeDeclaration.js | 1 - .../declFileAliasUseBeforeDeclaration.symbols | 1 - .../declFileAliasUseBeforeDeclaration.types | 1 - .../declFileAliasUseBeforeDeclaration2.js | 1 - ...declFileAliasUseBeforeDeclaration2.symbols | 15 +- .../declFileAliasUseBeforeDeclaration2.types | 1 - ...tExternalModuleWithSingleExportedModule.js | 1 - ...rnalModuleWithSingleExportedModule.symbols | 13 +- ...ternalModuleWithSingleExportedModule.types | 1 - .../reference/declFileCallSignatures.js | 1 - .../reference/declFileCallSignatures.symbols | 35 +- .../reference/declFileCallSignatures.types | 1 - .../reference/declFileClassExtendsNull.js | 1 - .../declFileClassExtendsNull.symbols | 1 - .../reference/declFileClassExtendsNull.types | 1 - .../declFileClassWithIndexSignature.js | 1 - .../declFileClassWithIndexSignature.symbols | 3 +- .../declFileClassWithIndexSignature.types | 1 - ...assWithStaticMethodReturningConstructor.js | 1 - ...thStaticMethodReturningConstructor.symbols | 3 +- ...WithStaticMethodReturningConstructor.types | 1 - .../reference/declFileConstructSignatures.js | 1 - .../declFileConstructSignatures.symbols | 39 +- .../declFileConstructSignatures.types | 1 - .../reference/declFileConstructors.js | 1 - .../reference/declFileConstructors.symbols | 45 +- .../reference/declFileConstructors.types | 1 - .../reference/declFileEnumUsedAsValue.js | 1 - .../reference/declFileEnumUsedAsValue.symbols | 9 +- .../reference/declFileEnumUsedAsValue.types | 1 - tests/baselines/reference/declFileEnums.js | 1 - .../baselines/reference/declFileEnums.symbols | 41 +- tests/baselines/reference/declFileEnums.types | 1 - ...lFileExportAssignmentOfGenericInterface.js | 1 - ...ExportAssignmentOfGenericInterface.symbols | 9 +- ...leExportAssignmentOfGenericInterface.types | 1 - .../reference/declFileExportImportChain.js | 1 - .../declFileExportImportChain.symbols | 9 +- .../reference/declFileExportImportChain.types | 1 - .../reference/declFileExportImportChain2.js | 1 - .../declFileExportImportChain2.symbols | 9 +- .../declFileExportImportChain2.types | 1 - ...declFileForClassWithMultipleBaseClasses.js | 1 - ...ileForClassWithMultipleBaseClasses.symbols | 33 +- ...lFileForClassWithMultipleBaseClasses.types | 1 - ...leForClassWithPrivateOverloadedFunction.js | 1 - ...ClassWithPrivateOverloadedFunction.symbols | 13 +- ...orClassWithPrivateOverloadedFunction.types | 1 - .../declFileForFunctionTypeAsTypeParameter.js | 1 - ...FileForFunctionTypeAsTypeParameter.symbols | 7 +- ...clFileForFunctionTypeAsTypeParameter.types | 1 - ...eclFileForInterfaceWithOptionalFunction.js | 1 - ...leForInterfaceWithOptionalFunction.symbols | 9 +- ...FileForInterfaceWithOptionalFunction.types | 1 - .../declFileForInterfaceWithRestParams.js | 1 - ...declFileForInterfaceWithRestParams.symbols | 23 +- .../declFileForInterfaceWithRestParams.types | 1 - .../reference/declFileForTypeParameters.js | 1 - .../declFileForTypeParameters.symbols | 19 +- .../reference/declFileForTypeParameters.types | 1 - .../baselines/reference/declFileForVarList.js | 1 - .../reference/declFileForVarList.symbols | 13 +- .../reference/declFileForVarList.types | 1 - .../baselines/reference/declFileFunctions.js | 1 - .../reference/declFileFunctions.symbols | 115 +- .../reference/declFileFunctions.types | 1 - .../reference/declFileGenericType2.js | 1 - .../reference/declFileGenericType2.symbols | 187 +- .../reference/declFileGenericType2.types | 1 - ...eclFileImportModuleWithExportAssignment.js | 1 - ...leImportModuleWithExportAssignment.symbols | 49 +- ...FileImportModuleWithExportAssignment.types | 1 - .../reference/declFileIndexSignatures.js | 1 - .../reference/declFileIndexSignatures.symbols | 21 +- .../reference/declFileIndexSignatures.types | 1 - tests/baselines/reference/declFileMethods.js | 1 - .../reference/declFileMethods.symbols | 169 +- .../baselines/reference/declFileMethods.types | 1 - ...ModuleAssignmentInObjectLiteralProperty.js | 1 - ...eAssignmentInObjectLiteralProperty.symbols | 17 +- ...uleAssignmentInObjectLiteralProperty.types | 1 - .../declFileModuleWithPropertyOfTypeModule.js | 1 - ...FileModuleWithPropertyOfTypeModule.symbols | 5 +- ...clFileModuleWithPropertyOfTypeModule.types | 1 - .../declFileObjectLiteralWithAccessors.js | 1 - ...declFileObjectLiteralWithAccessors.symbols | 31 +- .../declFileObjectLiteralWithAccessors.types | 1 - .../declFileObjectLiteralWithOnlyGetter.js | 1 - ...eclFileObjectLiteralWithOnlyGetter.symbols | 17 +- .../declFileObjectLiteralWithOnlyGetter.types | 1 - .../declFileObjectLiteralWithOnlySetter.js | 1 - ...eclFileObjectLiteralWithOnlySetter.symbols | 19 +- .../declFileObjectLiteralWithOnlySetter.types | 1 - .../declFilePrivateMethodOverloads.js | 1 - .../declFilePrivateMethodOverloads.symbols | 63 +- .../declFilePrivateMethodOverloads.types | 1 - .../reference/declFilePrivateStatic.js | 1 - .../reference/declFilePrivateStatic.symbols | 21 +- .../reference/declFilePrivateStatic.types | 1 - ...RestParametersOfFunctionAndFunctionType.js | 1 - ...arametersOfFunctionAndFunctionType.symbols | 29 +- ...tParametersOfFunctionAndFunctionType.types | 1 - .../declFileTypeAnnotationArrayType.js | 1 - .../declFileTypeAnnotationArrayType.symbols | 71 +- .../declFileTypeAnnotationArrayType.types | 1 - .../declFileTypeAnnotationBuiltInType.js | 1 - .../declFileTypeAnnotationBuiltInType.symbols | 19 +- .../declFileTypeAnnotationBuiltInType.types | 1 - .../declFileTypeAnnotationParenType.js | 1 - .../declFileTypeAnnotationParenType.symbols | 11 +- .../declFileTypeAnnotationParenType.types | 1 - .../declFileTypeAnnotationStringLiteral.js | 1 - ...eclFileTypeAnnotationStringLiteral.symbols | 23 +- .../declFileTypeAnnotationStringLiteral.types | 1 - .../declFileTypeAnnotationTupleType.js | 1 - .../declFileTypeAnnotationTupleType.symbols | 49 +- .../declFileTypeAnnotationTupleType.types | 1 - .../declFileTypeAnnotationTypeAlias.js | 1 - .../declFileTypeAnnotationTypeAlias.symbols | 47 +- .../declFileTypeAnnotationTypeAlias.types | 1 - .../declFileTypeAnnotationTypeLiteral.js | 1 - .../declFileTypeAnnotationTypeLiteral.symbols | 59 +- .../declFileTypeAnnotationTypeLiteral.types | 1 - .../declFileTypeAnnotationTypeQuery.js | 1 - .../declFileTypeAnnotationTypeQuery.symbols | 71 +- .../declFileTypeAnnotationTypeQuery.types | 1 - .../declFileTypeAnnotationTypeReference.js | 1 - ...eclFileTypeAnnotationTypeReference.symbols | 67 +- .../declFileTypeAnnotationTypeReference.types | 1 - .../declFileTypeAnnotationUnionType.js | 1 - .../declFileTypeAnnotationUnionType.symbols | 67 +- .../declFileTypeAnnotationUnionType.types | 1 - ...otationVisibilityErrorAccessors.errors.txt | 21 +- ...eTypeAnnotationVisibilityErrorAccessors.js | 1 - ...ibilityErrorParameterOfFunction.errors.txt | 9 +- ...ationVisibilityErrorParameterOfFunction.js | 1 - ...bilityErrorReturnTypeOfFunction.errors.txt | 9 +- ...tionVisibilityErrorReturnTypeOfFunction.js | 1 - ...otationVisibilityErrorTypeAlias.errors.txt | 9 +- ...eTypeAnnotationVisibilityErrorTypeAlias.js | 1 - ...ationVisibilityErrorTypeLiteral.errors.txt | 37 +- ...ypeAnnotationVisibilityErrorTypeLiteral.js | 1 - ...ibilityErrorVariableDeclaration.errors.txt | 9 +- ...ationVisibilityErrorVariableDeclaration.js | 1 - .../reference/declFileTypeofClass.js | 1 - .../reference/declFileTypeofClass.symbols | 23 +- .../reference/declFileTypeofClass.types | 1 - .../baselines/reference/declFileTypeofEnum.js | 1 - .../reference/declFileTypeofEnum.symbols | 25 +- .../reference/declFileTypeofEnum.types | 1 - .../reference/declFileTypeofFunction.js | 1 - .../reference/declFileTypeofFunction.symbols | 69 +- .../reference/declFileTypeofFunction.types | 1 - .../declFileTypeofInAnonymousType.js | 1 - .../declFileTypeofInAnonymousType.symbols | 63 +- .../declFileTypeofInAnonymousType.types | 1 - .../reference/declFileTypeofModule.js | 1 - .../reference/declFileTypeofModule.symbols | 21 +- .../reference/declFileTypeofModule.types | 1 - ...lictingWithClassReferredByExtendsClause.js | 1 - ...ngWithClassReferredByExtendsClause.symbols | 59 +- ...tingWithClassReferredByExtendsClause.types | 1 - ...ithErrorsInInputDeclarationFile.errors.txt | 7 +- ...eclFileWithErrorsInInputDeclarationFile.js | 1 - ...rsInInputDeclarationFileWithOut.errors.txt | 7 +- ...WithErrorsInInputDeclarationFileWithOut.js | 1 - ...dsClauseThatHasItsContainerNameConflict.js | 1 - ...useThatHasItsContainerNameConflict.symbols | 29 +- ...lauseThatHasItsContainerNameConflict.types | 1 - ...rnalModuleNameConflictsInExtendsClause1.js | 1 - ...oduleNameConflictsInExtendsClause1.symbols | 35 +- ...lModuleNameConflictsInExtendsClause1.types | 1 - ...rnalModuleNameConflictsInExtendsClause2.js | 1 - ...oduleNameConflictsInExtendsClause2.symbols | 39 +- ...lModuleNameConflictsInExtendsClause2.types | 1 - ...rnalModuleNameConflictsInExtendsClause3.js | 1 - ...oduleNameConflictsInExtendsClause3.symbols | 43 +- ...lModuleNameConflictsInExtendsClause3.types | 1 - .../declarationEmitBindingPatterns.js | 1 - .../declarationEmitBindingPatterns.symbols | 17 +- .../declarationEmitBindingPatterns.types | 1 - .../declarationEmitClassMemberNameConflict.js | 1 - ...arationEmitClassMemberNameConflict.symbols | 39 +- ...clarationEmitClassMemberNameConflict.types | 1 - ...declarationEmitClassMemberNameConflict2.js | 1 - ...rationEmitClassMemberNameConflict2.symbols | 25 +- ...larationEmitClassMemberNameConflict2.types | 1 - .../declarationEmitDefaultExport8.js | 1 - .../declarationEmitDefaultExport8.symbols | 7 +- .../declarationEmitDefaultExport8.types | 1 - ...efaultExportWithTempVarNameWithBundling.js | 1 - ...tExportWithTempVarNameWithBundling.symbols | 3 +- ...ultExportWithTempVarNameWithBundling.types | 3 +- ...clarationEmitDestructuringArrayPattern1.js | 1 - ...tionEmitDestructuringArrayPattern1.symbols | 23 +- ...rationEmitDestructuringArrayPattern1.types | 1 - ...structuringObjectLiteralPattern.errors.txt | 13 +- ...onEmitDestructuringObjectLiteralPattern.js | 1 - ...tructuringObjectLiteralPattern1.errors.txt | 13 +- ...nEmitDestructuringObjectLiteralPattern1.js | 1 - ...nEmitDestructuringObjectLiteralPattern2.js | 1 - ...DestructuringObjectLiteralPattern2.symbols | 59 +- ...itDestructuringObjectLiteralPattern2.types | 1 - ...ingOptionalBindingParametersInOverloads.js | 1 - ...tionalBindingParametersInOverloads.symbols | 31 +- ...OptionalBindingParametersInOverloads.types | 1 - .../declarationEmitDetachedComment1.js | 1 - .../declarationEmitDetachedComment1.symbols | 1 - .../declarationEmitDetachedComment1.types | 1 - .../declarationEmitDetachedComment2.js | 1 - .../declarationEmitDetachedComment2.symbols | 1 - .../declarationEmitDetachedComment2.types | 1 - .../declarationEmitExportAssignment.js | 1 - .../declarationEmitExportAssignment.symbols | 5 +- .../declarationEmitExportAssignment.types | 1 - .../declarationEmitExportDeclaration.js | 1 - .../declarationEmitExportDeclaration.symbols | 5 +- .../declarationEmitExportDeclaration.types | 1 - .../declarationEmitExpressionInExtends.js | 1 - ...declarationEmitExpressionInExtends.symbols | 27 +- .../declarationEmitExpressionInExtends.types | 1 - .../declarationEmitExpressionInExtends2.js | 1 - ...eclarationEmitExpressionInExtends2.symbols | 25 +- .../declarationEmitExpressionInExtends2.types | 1 - ...arationEmitExpressionInExtends3.errors.txt | 5 +- .../declarationEmitExpressionInExtends3.js | 1 - ...arationEmitExpressionInExtends4.errors.txt | 15 +- .../declarationEmitExpressionInExtends4.js | 1 - .../declarationEmitFBoundedTypeParams.js | 1 - .../declarationEmitFBoundedTypeParams.symbols | 23 +- .../declarationEmitFBoundedTypeParams.types | 1 - ...mitFirstTypeArgumentGenericFunctionType.js | 1 - ...rstTypeArgumentGenericFunctionType.symbols | 85 +- ...FirstTypeArgumentGenericFunctionType.types | 1 - .../declarationEmitIdentifierPredicates01.js | 1 - ...larationEmitIdentifierPredicates01.symbols | 7 +- ...eclarationEmitIdentifierPredicates01.types | 1 - ...fierPredicatesWithPrivateName01.errors.txt | 3 +- ...itIdentifierPredicatesWithPrivateName01.js | 1 - ...ationEmitImportInExportAssignmentModule.js | 1 - ...EmitImportInExportAssignmentModule.symbols | 13 +- ...onEmitImportInExportAssignmentModule.types | 1 - ...eclarationEmitIndexTypeNotFound.errors.txt | 7 +- .../declarationEmitIndexTypeNotFound.js | 1 - ...declarationEmitInferedDefaultExportType.js | 1 - ...rationEmitInferedDefaultExportType.symbols | 7 +- ...larationEmitInferedDefaultExportType.types | 1 - ...eclarationEmitInferedDefaultExportType2.js | 1 - ...ationEmitInferedDefaultExportType2.symbols | 7 +- ...arationEmitInferedDefaultExportType2.types | 1 - .../declarationEmitInferedTypeAlias1.js | 1 - .../declarationEmitInferedTypeAlias1.symbols | 7 +- .../declarationEmitInferedTypeAlias1.types | 1 - .../declarationEmitInferedTypeAlias2.js | 1 - .../declarationEmitInferedTypeAlias2.symbols | 7 +- .../declarationEmitInferedTypeAlias2.types | 1 - .../declarationEmitInferedTypeAlias3.js | 1 - .../declarationEmitInferedTypeAlias3.symbols | 7 +- .../declarationEmitInferedTypeAlias3.types | 1 - .../declarationEmitInferedTypeAlias4.js | 1 - .../declarationEmitInferedTypeAlias4.symbols | 23 +- .../declarationEmitInferedTypeAlias4.types | 1 - .../declarationEmitInferedTypeAlias5.js | 1 - .../declarationEmitInferedTypeAlias5.symbols | 3 +- .../declarationEmitInferedTypeAlias5.types | 1 - .../declarationEmitInferedTypeAlias6.js | 1 - .../declarationEmitInferedTypeAlias6.symbols | 7 +- .../declarationEmitInferedTypeAlias6.types | 1 - .../declarationEmitInferedTypeAlias7.js | 1 - .../declarationEmitInferedTypeAlias7.symbols | 3 +- .../declarationEmitInferedTypeAlias7.types | 1 - .../declarationEmitInferedTypeAlias8.js | 1 - .../declarationEmitInferedTypeAlias8.symbols | 15 +- .../declarationEmitInferedTypeAlias8.types | 1 - .../declarationEmitInferedTypeAlias9.js | 1 - .../declarationEmitInferedTypeAlias9.symbols | 15 +- .../declarationEmitInferedTypeAlias9.types | 1 - ...NonEntityNameExpressionHeritage.errors.txt | 3 +- ...faceWithNonEntityNameExpressionHeritage.js | 1 - .../declarationEmitInvalidExport.errors.txt | 7 +- .../reference/declarationEmitInvalidExport.js | 1 - .../reference/declarationEmitPromise.js | 1 - .../reference/declarationEmitPromise.symbols | 193 +- .../reference/declarationEmitPromise.types | 1 - .../declarationEmitProtectedMembers.js | 1 - .../declarationEmitProtectedMembers.symbols | 87 +- .../declarationEmitProtectedMembers.types | 1 - .../reference/declarationEmitReadonly.js | 1 - .../reference/declarationEmitReadonly.symbols | 3 +- .../reference/declarationEmitReadonly.types | 1 - .../declarationEmitThisPredicates01.js | 1 - .../declarationEmitThisPredicates01.symbols | 9 +- .../declarationEmitThisPredicates01.types | 1 - ...declarationEmitThisPredicates02.errors.txt | 3 +- .../declarationEmitThisPredicates02.js | 1 - ...ThisPredicatesWithPrivateName01.errors.txt | 3 +- ...tionEmitThisPredicatesWithPrivateName01.js | 1 - ...ThisPredicatesWithPrivateName02.errors.txt | 5 +- ...tionEmitThisPredicatesWithPrivateName02.js | 1 - ...ParameterExtendingUnknownSymbol.errors.txt | 5 +- ...liasTypeParameterExtendingUnknownSymbol.js | 1 - ...arationEmitTypeAliasWithTypeParameters1.js | 1 - ...onEmitTypeAliasWithTypeParameters1.symbols | 21 +- ...tionEmitTypeAliasWithTypeParameters1.types | 1 - ...arationEmitTypeAliasWithTypeParameters2.js | 1 - ...onEmitTypeAliasWithTypeParameters2.symbols | 37 +- ...tionEmitTypeAliasWithTypeParameters2.types | 1 - ...arationEmitTypeAliasWithTypeParameters3.js | 1 - ...onEmitTypeAliasWithTypeParameters3.symbols | 11 +- ...tionEmitTypeAliasWithTypeParameters3.types | 1 - ...arationEmitTypeAliasWithTypeParameters4.js | 1 - ...onEmitTypeAliasWithTypeParameters4.symbols | 25 +- ...tionEmitTypeAliasWithTypeParameters4.types | 1 - ...mitTypeAliasWithTypeParameters5.errors.txt | 3 +- ...arationEmitTypeAliasWithTypeParameters5.js | 1 - ...arationEmitTypeAliasWithTypeParameters6.js | 1 - ...onEmitTypeAliasWithTypeParameters6.symbols | 29 +- ...tionEmitTypeAliasWithTypeParameters6.types | 1 - .../declarationEmitUnknownImport.errors.txt | 7 +- .../reference/declarationEmitUnknownImport.js | 1 - .../declarationEmitUnknownImport2.errors.txt | 11 +- .../declarationEmitUnknownImport2.js | 1 - .../declarationFileOverwriteError.errors.txt | 1 - .../declarationFileOverwriteError.js | 1 - ...rationFileOverwriteErrorWithOut.errors.txt | 1 - .../declarationFileOverwriteErrorWithOut.js | 1 - .../reference/declarationFiles.errors.txt | 11 +- tests/baselines/reference/declarationFiles.js | 1 - .../declarationFilesWithTypeReferences1.js | 2 - ...eclarationFilesWithTypeReferences1.symbols | 4 +- .../declarationFilesWithTypeReferences1.types | 2 - .../declarationFilesWithTypeReferences2.js | 2 - ...eclarationFilesWithTypeReferences2.symbols | 4 +- .../declarationFilesWithTypeReferences2.types | 2 - .../declarationFilesWithTypeReferences3.js | 1 - ...eclarationFilesWithTypeReferences3.symbols | 3 +- .../declarationFilesWithTypeReferences3.types | 1 - .../declarationFilesWithTypeReferences4.js | 1 - ...eclarationFilesWithTypeReferences4.symbols | 3 +- .../declarationFilesWithTypeReferences4.types | 1 - .../reference/declarationMerging2.js | 1 - .../reference/declarationMerging2.symbols | 9 +- .../reference/declarationMerging2.types | 1 - .../declaredClassMergedwithSelf.errors.txt | 16 +- .../reference/declaredClassMergedwithSelf.js | 4 - .../decoratedClassExportsCommonJS2.js | 1 - .../decoratedClassExportsCommonJS2.symbols | 13 +- .../decoratedClassExportsCommonJS2.types | 1 - .../reference/decoratedClassExportsSystem1.js | 1 - .../decoratedClassExportsSystem1.symbols | 23 +- .../decoratedClassExportsSystem1.types | 1 - .../reference/decoratedClassExportsSystem2.js | 1 - .../decoratedClassExportsSystem2.symbols | 13 +- .../decoratedClassExportsSystem2.types | 1 - .../decoratorChecksFunctionBodies.errors.txt | 3 +- .../decoratorChecksFunctionBodies.js | 1 - .../reference/decoratorInJsFile.errors.txt | 3 +- .../reference/decoratorInJsFile1.errors.txt | 5 +- ...ratorInstantiateModulesInFunctionBodies.js | 1 - ...InstantiateModulesInFunctionBodies.symbols | 3 +- ...orInstantiateModulesInFunctionBodies.types | 1 - ...taForMethodWithNoReturnTypeAnnotation01.js | 1 - ...MethodWithNoReturnTypeAnnotation01.symbols | 13 +- ...orMethodWithNoReturnTypeAnnotation01.types | 1 - .../decoratorMetadataOnInferredType.js | 1 - .../decoratorMetadataOnInferredType.symbols | 29 +- .../decoratorMetadataOnInferredType.types | 1 - .../reference/decoratorMetadataPromise.js | 1 - .../decoratorMetadataPromise.symbols | 21 +- .../reference/decoratorMetadataPromise.types | 1 - ...orMetadataRestParameterWithImportedType.js | 1 - ...adataRestParameterWithImportedType.symbols | 3 +- ...etadataRestParameterWithImportedType.types | 1 - .../decoratorMetadataWithConstructorType.js | 1 - ...coratorMetadataWithConstructorType.symbols | 31 +- ...decoratorMetadataWithConstructorType.types | 1 - .../decoratorOnClassConstructor2.errors.txt | 1 - .../reference/decoratorOnClassConstructor2.js | 1 - .../reference/decoratorOnClassConstructor3.js | 1 - .../decoratorOnClassConstructor3.symbols | 9 +- .../decoratorOnClassConstructor3.types | 1 - .../decoratorWithUnderscoreMethod.js | 1 - .../decoratorWithUnderscoreMethod.symbols | 33 +- .../decoratorWithUnderscoreMethod.types | 1 - .../reference/defaultExportWithOverloads01.js | 1 - .../defaultExportWithOverloads01.symbols | 11 +- .../defaultExportWithOverloads01.types | 1 - .../defaultExportsCannotMerge01.errors.txt | 5 +- .../reference/defaultExportsCannotMerge01.js | 1 - .../defaultExportsCannotMerge02.errors.txt | 5 +- .../reference/defaultExportsCannotMerge02.js | 1 - .../defaultExportsCannotMerge03.errors.txt | 5 +- .../reference/defaultExportsCannotMerge03.js | 1 - .../defaultExportsCannotMerge04.errors.txt | 9 +- .../reference/defaultExportsCannotMerge04.js | 1 - .../defaultOfAnyInStrictNullChecks.js | 1 - .../defaultOfAnyInStrictNullChecks.symbols | 7 +- .../defaultOfAnyInStrictNullChecks.types | 1 - ...edClassConstructorWithExplicitReturns01.js | 1 - ...assConstructorWithExplicitReturns01.js.map | 2 +- ...tructorWithExplicitReturns01.sourcemap.txt | 265 +- ...ssConstructorWithExplicitReturns01.symbols | 31 +- ...lassConstructorWithExplicitReturns01.types | 1 - .../derivedClassOverridesProtectedMembers.js | 1 - ...ivedClassOverridesProtectedMembers.symbols | 133 +- ...erivedClassOverridesProtectedMembers.types | 1 - ...ClassOverridesProtectedMembers3.errors.txt | 21 +- .../derivedClassOverridesProtectedMembers3.js | 1 - ...tanceShadowingProtectedInstance.errors.txt | 3 +- ...ivateInstanceShadowingProtectedInstance.js | 1 - ...eStaticShadowingProtectedStatic.errors.txt | 3 +- ...thPrivateStaticShadowingProtectedStatic.js | 1 - .../reference/destructureOptionalParameter.js | 1 - .../destructureOptionalParameter.symbols | 63 +- .../destructureOptionalParameter.types | 1 - ...BindingPatternAndAssignment1ES6.errors.txt | 7 +- ...ingArrayBindingPatternAndAssignment1ES6.js | 1 - .../baselines/reference/destructuringCatch.js | 1 - .../reference/destructuringCatch.symbols | 35 +- .../reference/destructuringCatch.types | 1 - .../reference/destructuringInFunctionType.js | 1 - .../destructuringInFunctionType.symbols | 83 +- .../destructuringInFunctionType.types | 1 - .../destructuringParameterDeclaration3ES5.js | 1 - ...tructuringParameterDeclaration3ES5.symbols | 131 +- ...estructuringParameterDeclaration3ES5.types | 1 - ...cturingParameterDeclaration3ES5iterable.js | 1 - ...ngParameterDeclaration3ES5iterable.symbols | 131 +- ...ringParameterDeclaration3ES5iterable.types | 1 - .../destructuringParameterDeclaration3ES6.js | 1 - ...tructuringParameterDeclaration3ES6.symbols | 131 +- ...estructuringParameterDeclaration3ES6.types | 1 - .../destructuringParameterDeclaration7ES5.js | 1 - ...tructuringParameterDeclaration7ES5.symbols | 27 +- ...estructuringParameterDeclaration7ES5.types | 1 - ...cturingParameterDeclaration7ES5iterable.js | 1 - ...ngParameterDeclaration7ES5iterable.symbols | 27 +- ...ringParameterDeclaration7ES5iterable.types | 1 - ...structuringParameterProperties4.errors.txt | 21 +- .../destructuringParameterProperties4.js | 1 - .../discriminantPropertyCheck.errors.txt | 5 +- .../reference/discriminantPropertyCheck.js | 1 - .../discriminantsAndNullOrUndefined.js | 1 - .../discriminantsAndNullOrUndefined.symbols | 49 +- .../discriminantsAndNullOrUndefined.types | 1 - .../reference/discriminantsAndPrimitives.js | 1 - .../discriminantsAndPrimitives.symbols | 95 +- .../discriminantsAndPrimitives.types | 1 - .../doNotEmitPinnedCommentOnNotEmittedNode.js | 1 - ...tEmitPinnedCommentOnNotEmittedNode.symbols | 17 +- ...NotEmitPinnedCommentOnNotEmittedNode.types | 1 - ...oNotEmitPinnedCommentOnNotEmittedNodets.js | 1 - ...mitPinnedCommentOnNotEmittedNodets.symbols | 15 +- ...tEmitPinnedCommentOnNotEmittedNodets.types | 1 - ...doNotEmitTripleSlashCommentsInEmptyFile.js | 1 - ...EmitTripleSlashCommentsInEmptyFile.symbols | 1 - ...otEmitTripleSlashCommentsInEmptyFile.types | 1 - ...EmitTripleSlashCommentsOnNotEmittedNode.js | 1 - ...ripleSlashCommentsOnNotEmittedNode.symbols | 3 +- ...tTripleSlashCommentsOnNotEmittedNode.types | 1 - .../reference/doNotemitTripleSlashComments.js | 1 - .../doNotemitTripleSlashComments.symbols | 5 +- .../doNotemitTripleSlashComments.types | 1 - .../reference/doWhileBreakStatements.js | 1 - .../reference/doWhileBreakStatements.symbols | 3 +- .../reference/doWhileBreakStatements.types | 1 - .../reference/doWhileContinueStatements.js | 1 - .../doWhileContinueStatements.symbols | 3 +- .../reference/doWhileContinueStatements.types | 1 - .../reference/downlevelLetConst12.errors.txt | 5 +- .../reference/downlevelLetConst12.js | 1 - .../reference/downlevelLetConst13.js | 1 - .../reference/downlevelLetConst13.symbols | 43 +- .../reference/downlevelLetConst13.types | 1 - .../reference/downlevelLetConst16.errors.txt | 13 +- .../reference/downlevelLetConst16.js | 1 - .../reference/downlevelLetConst18.errors.txt | 5 +- .../reference/downlevelLetConst18.js | 1 - ...gElementInParameterDeclaration1.errors.txt | 41 +- ...erBindingElementInParameterDeclaration1.js | 1 - ...gElementInParameterDeclaration2.errors.txt | 41 +- ...erBindingElementInParameterDeclaration2.js | 1 - ...IdentifiersAcrossFileBoundaries.errors.txt | 7 +- ...uplicateIdentifiersAcrossFileBoundaries.js | 1 - .../reference/duplicateLabel1.errors.txt | 3 +- tests/baselines/reference/duplicateLabel1.js | 1 - .../reference/duplicateLabel2.errors.txt | 3 +- tests/baselines/reference/duplicateLabel2.js | 1 - tests/baselines/reference/duplicateLabel3.js | 1 - .../reference/duplicateLabel3.symbols | 3 +- .../baselines/reference/duplicateLabel3.types | 1 - tests/baselines/reference/duplicateLabel4.js | 1 - .../reference/duplicateLabel4.symbols | 3 +- .../baselines/reference/duplicateLabel4.types | 1 - .../duplicateLocalVariable1.errors.txt | 13 +- .../reference/duplicateLocalVariable1.js | 1 - ...atePropertiesInTypeAssertions01.errors.txt | 5 +- .../duplicatePropertiesInTypeAssertions01.js | 1 - ...atePropertiesInTypeAssertions02.errors.txt | 5 +- .../duplicatePropertiesInTypeAssertions02.js | 1 - .../reference/duplicateVariablesByScope.js | 1 - .../duplicateVariablesByScope.symbols | 33 +- .../reference/duplicateVariablesByScope.types | 1 - tests/baselines/reference/dynamicRequire.js | 1 - .../reference/dynamicRequire.symbols | 7 +- .../baselines/reference/dynamicRequire.types | 1 - .../baselines/reference/elidingImportNames.js | 1 - .../reference/elidingImportNames.symbols | 11 +- .../reference/elidingImportNames.types | 1 - ...rowFunctionWhenUsingArguments02.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments02.js | 1 - ...itArrowFunctionWhenUsingArguments02_ES6.js | 1 - ...owFunctionWhenUsingArguments02_ES6.symbols | 3 +- ...rrowFunctionWhenUsingArguments02_ES6.types | 1 - ...rowFunctionWhenUsingArguments03.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments03.js | 1 - ...itArrowFunctionWhenUsingArguments03_ES6.js | 1 - ...owFunctionWhenUsingArguments03_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments03_ES6.types | 1 - ...rowFunctionWhenUsingArguments04.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments04.js | 1 - ...itArrowFunctionWhenUsingArguments04_ES6.js | 1 - ...owFunctionWhenUsingArguments04_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments04_ES6.types | 1 - ...rowFunctionWhenUsingArguments05.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments05.js | 1 - ...itArrowFunctionWhenUsingArguments05_ES6.js | 1 - ...owFunctionWhenUsingArguments05_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments05_ES6.types | 1 - ...rowFunctionWhenUsingArguments06.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments06.js | 1 - ...itArrowFunctionWhenUsingArguments06_ES6.js | 1 - ...owFunctionWhenUsingArguments06_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments06_ES6.types | 1 - ...rowFunctionWhenUsingArguments07.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments07.js | 1 - ...itArrowFunctionWhenUsingArguments07_ES6.js | 1 - ...owFunctionWhenUsingArguments07_ES6.symbols | 7 +- ...rrowFunctionWhenUsingArguments07_ES6.types | 1 - .../emitArrowFunctionWhenUsingArguments08.js | 1 - ...tArrowFunctionWhenUsingArguments08.symbols | 9 +- ...mitArrowFunctionWhenUsingArguments08.types | 1 - ...itArrowFunctionWhenUsingArguments08_ES6.js | 1 - ...owFunctionWhenUsingArguments08_ES6.symbols | 9 +- ...rrowFunctionWhenUsingArguments08_ES6.types | 1 - ...rowFunctionWhenUsingArguments09.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments09.js | 1 - ...itArrowFunctionWhenUsingArguments09_ES6.js | 1 - ...owFunctionWhenUsingArguments09_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments09_ES6.types | 1 - ...rowFunctionWhenUsingArguments10.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments10.js | 1 - ...itArrowFunctionWhenUsingArguments10_ES6.js | 1 - ...owFunctionWhenUsingArguments10_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments10_ES6.types | 1 - ...rowFunctionWhenUsingArguments11.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments11.js | 1 - ...itArrowFunctionWhenUsingArguments11_ES6.js | 1 - ...owFunctionWhenUsingArguments11_ES6.symbols | 7 +- ...rrowFunctionWhenUsingArguments11_ES6.types | 1 - ...rowFunctionWhenUsingArguments12.errors.txt | 5 +- .../emitArrowFunctionWhenUsingArguments12.js | 1 - ...unctionWhenUsingArguments12_ES6.errors.txt | 3 +- ...itArrowFunctionWhenUsingArguments12_ES6.js | 1 - .../emitArrowFunctionWhenUsingArguments13.js | 1 - ...tArrowFunctionWhenUsingArguments13.symbols | 9 +- ...mitArrowFunctionWhenUsingArguments13.types | 1 - ...itArrowFunctionWhenUsingArguments13_ES6.js | 1 - ...owFunctionWhenUsingArguments13_ES6.symbols | 9 +- ...rrowFunctionWhenUsingArguments13_ES6.types | 1 - ...rowFunctionWhenUsingArguments14.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments14.js | 1 - ...itArrowFunctionWhenUsingArguments14_ES6.js | 1 - ...owFunctionWhenUsingArguments14_ES6.symbols | 3 +- ...rrowFunctionWhenUsingArguments14_ES6.types | 1 - ...rowFunctionWhenUsingArguments15.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments15.js | 1 - ...itArrowFunctionWhenUsingArguments15_ES6.js | 1 - ...owFunctionWhenUsingArguments15_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments15_ES6.types | 1 - ...rowFunctionWhenUsingArguments16.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments16.js | 1 - ...itArrowFunctionWhenUsingArguments16_ES6.js | 1 - ...owFunctionWhenUsingArguments16_ES6.symbols | 5 +- ...rrowFunctionWhenUsingArguments16_ES6.types | 1 - ...rowFunctionWhenUsingArguments17.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments17.js | 1 - ...itArrowFunctionWhenUsingArguments17_ES6.js | 1 - ...owFunctionWhenUsingArguments17_ES6.symbols | 7 +- ...rrowFunctionWhenUsingArguments17_ES6.types | 1 - ...rowFunctionWhenUsingArguments18.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments18.js | 1 - ...itArrowFunctionWhenUsingArguments18_ES6.js | 1 - ...owFunctionWhenUsingArguments18_ES6.symbols | 7 +- ...rrowFunctionWhenUsingArguments18_ES6.types | 1 - ...rowFunctionWhenUsingArguments19.errors.txt | 3 +- .../emitArrowFunctionWhenUsingArguments19.js | 1 - ...itArrowFunctionWhenUsingArguments19_ES6.js | 1 - ...owFunctionWhenUsingArguments19_ES6.symbols | 17 +- ...rrowFunctionWhenUsingArguments19_ES6.types | 1 - tests/baselines/reference/emitBOM.js | 1 - tests/baselines/reference/emitBOM.js.map | 2 +- .../baselines/reference/emitBOM.sourcemap.txt | 15 +- tests/baselines/reference/emitBOM.symbols | 3 +- tests/baselines/reference/emitBOM.types | 1 - .../reference/emitBundleWithShebang1.js | 29 + .../reference/emitBundleWithShebang1.symbols | 9 + .../reference/emitBundleWithShebang1.types | 9 + .../reference/emitBundleWithShebang2.js | 49 + .../reference/emitBundleWithShebang2.symbols | 18 + .../reference/emitBundleWithShebang2.types | 18 + ...itClassDeclarationWithSuperMethodCall01.js | 1 - ...ssDeclarationWithSuperMethodCall01.symbols | 13 +- ...lassDeclarationWithSuperMethodCall01.types | 1 - .../reference/emitCommentsOnlyFile.js | 1 - .../reference/emitCommentsOnlyFile.symbols | 3 +- .../reference/emitCommentsOnlyFile.types | 3 +- ...onentiationAssignmentWithIndexingOnLHS1.js | 1 - ...iationAssignmentWithIndexingOnLHS1.symbols | 51 +- ...ntiationAssignmentWithIndexingOnLHS1.types | 1 - ...onentiationAssignmentWithIndexingOnLHS3.js | 1 - ...iationAssignmentWithIndexingOnLHS3.symbols | 33 +- ...ntiationAssignmentWithIndexingOnLHS3.types | 1 - ...onentiationAssignmentWithIndexingOnLHS4.js | 1 - ...iationAssignmentWithIndexingOnLHS4.symbols | 47 +- ...ntiationAssignmentWithIndexingOnLHS4.types | 1 - ...onAssignmentWithPropertyAccessingOnLHS1.js | 1 - ...ignmentWithPropertyAccessingOnLHS1.symbols | 75 +- ...ssignmentWithPropertyAccessingOnLHS1.types | 1 - .../emitCompoundExponentiationOperator1.js | 1 - ...mitCompoundExponentiationOperator1.symbols | 87 +- .../emitCompoundExponentiationOperator1.types | 1 - .../emitCompoundExponentiationOperator2.js | 1 - ...mitCompoundExponentiationOperator2.symbols | 73 +- .../emitCompoundExponentiationOperator2.types | 1 - .../emitDecoratorMetadata_restArgs.js | 1 - .../emitDecoratorMetadata_restArgs.symbols | 31 +- .../emitDecoratorMetadata_restArgs.types | 1 - .../reference/emitExponentiationOperator1.js | 1 - .../emitExponentiationOperator1.symbols | 3 +- .../emitExponentiationOperator1.types | 1 - .../reference/emitExponentiationOperator2.js | 1 - .../emitExponentiationOperator2.symbols | 117 +- .../emitExponentiationOperator2.types | 1 - .../reference/emitExponentiationOperator3.js | 1 - .../emitExponentiationOperator3.symbols | 71 +- .../emitExponentiationOperator3.types | 1 - ...ExponentiationOperatorInTempalteString4.js | 1 - ...entiationOperatorInTempalteString4.symbols | 139 +- ...onentiationOperatorInTempalteString4.types | 1 - ...onentiationOperatorInTempalteString4ES6.js | 1 - ...iationOperatorInTempalteString4ES6.symbols | 139 +- ...ntiationOperatorInTempalteString4ES6.types | 1 - ...ExponentiationOperatorInTemplateString1.js | 1 - ...entiationOperatorInTemplateString1.symbols | 193 +- ...onentiationOperatorInTemplateString1.types | 1 - ...onentiationOperatorInTemplateString1ES6.js | 1 - ...iationOperatorInTemplateString1ES6.symbols | 193 +- ...ntiationOperatorInTemplateString1ES6.types | 1 - ...ExponentiationOperatorInTemplateString2.js | 1 - ...entiationOperatorInTemplateString2.symbols | 193 +- ...onentiationOperatorInTemplateString2.types | 1 - ...onentiationOperatorInTemplateString2ES6.js | 1 - ...iationOperatorInTemplateString2ES6.symbols | 193 +- ...ntiationOperatorInTemplateString2ES6.types | 1 - ...ExponentiationOperatorInTemplateString3.js | 1 - ...entiationOperatorInTemplateString3.symbols | 193 +- ...onentiationOperatorInTemplateString3.types | 1 - ...onentiationOperatorInTemplateString3ES6.js | 1 - ...iationOperatorInTemplateString3ES6.symbols | 193 +- ...ntiationOperatorInTemplateString3ES6.types | 1 - tests/baselines/reference/emitPostComments.js | 1 - .../reference/emitPostComments.symbols | 3 +- .../reference/emitPostComments.types | 1 - tests/baselines/reference/emitPreComments.js | 1 - .../reference/emitPreComments.symbols | 3 +- .../baselines/reference/emitPreComments.types | 1 - ...OnNotEmittedNodeIfRemoveCommentsIsFalse.js | 1 - ...EmittedNodeIfRemoveCommentsIsFalse.symbols | 3 +- ...otEmittedNodeIfRemoveCommentsIsFalse.types | 1 - .../emptyArrayBindingPatternParameter01.js | 1 - ...mptyArrayBindingPatternParameter01.symbols | 7 +- .../emptyArrayBindingPatternParameter01.types | 1 - .../emptyArrayBindingPatternParameter02.js | 1 - ...mptyArrayBindingPatternParameter02.symbols | 9 +- .../emptyArrayBindingPatternParameter02.types | 1 - .../emptyArrayBindingPatternParameter03.js | 1 - ...mptyArrayBindingPatternParameter03.symbols | 9 +- .../emptyArrayBindingPatternParameter03.types | 1 - .../emptyArrayBindingPatternParameter04.js | 1 - ...mptyArrayBindingPatternParameter04.symbols | 7 +- .../emptyArrayBindingPatternParameter04.types | 1 - .../emptyAssignmentPatterns01_ES5.js | 1 - .../emptyAssignmentPatterns01_ES5.symbols | 7 +- .../emptyAssignmentPatterns01_ES5.types | 1 - .../emptyAssignmentPatterns01_ES5iterable.js | 1 - ...tyAssignmentPatterns01_ES5iterable.symbols | 7 +- ...mptyAssignmentPatterns01_ES5iterable.types | 1 - .../emptyAssignmentPatterns01_ES6.js | 1 - .../emptyAssignmentPatterns01_ES6.symbols | 7 +- .../emptyAssignmentPatterns01_ES6.types | 1 - .../emptyAssignmentPatterns02_ES5.js | 1 - .../emptyAssignmentPatterns02_ES5.symbols | 31 +- .../emptyAssignmentPatterns02_ES5.types | 1 - .../emptyAssignmentPatterns02_ES5iterable.js | 1 - ...tyAssignmentPatterns02_ES5iterable.symbols | 31 +- ...mptyAssignmentPatterns02_ES5iterable.types | 1 - .../emptyAssignmentPatterns02_ES6.js | 1 - .../emptyAssignmentPatterns02_ES6.symbols | 31 +- .../emptyAssignmentPatterns02_ES6.types | 1 - .../emptyAssignmentPatterns03_ES5.js | 1 - .../emptyAssignmentPatterns03_ES5.symbols | 7 +- .../emptyAssignmentPatterns03_ES5.types | 1 - .../emptyAssignmentPatterns03_ES5iterable.js | 1 - ...tyAssignmentPatterns03_ES5iterable.symbols | 7 +- ...mptyAssignmentPatterns03_ES5iterable.types | 1 - .../emptyAssignmentPatterns03_ES6.js | 1 - .../emptyAssignmentPatterns03_ES6.symbols | 7 +- .../emptyAssignmentPatterns03_ES6.types | 1 - .../emptyAssignmentPatterns04_ES5.js | 1 - .../emptyAssignmentPatterns04_ES5.symbols | 31 +- .../emptyAssignmentPatterns04_ES5.types | 1 - .../emptyAssignmentPatterns04_ES5iterable.js | 1 - ...tyAssignmentPatterns04_ES5iterable.symbols | 31 +- ...mptyAssignmentPatterns04_ES5iterable.types | 1 - .../emptyAssignmentPatterns04_ES6.js | 1 - .../emptyAssignmentPatterns04_ES6.symbols | 31 +- .../emptyAssignmentPatterns04_ES6.types | 1 - .../emptyObjectBindingPatternParameter01.js | 1 - ...ptyObjectBindingPatternParameter01.symbols | 7 +- ...emptyObjectBindingPatternParameter01.types | 1 - .../emptyObjectBindingPatternParameter02.js | 1 - ...ptyObjectBindingPatternParameter02.symbols | 9 +- ...emptyObjectBindingPatternParameter02.types | 1 - .../emptyObjectBindingPatternParameter03.js | 1 - ...ptyObjectBindingPatternParameter03.symbols | 9 +- ...emptyObjectBindingPatternParameter03.types | 1 - ...ObjectBindingPatternParameter04.errors.txt | 7 +- .../emptyObjectBindingPatternParameter04.js | 1 - .../emptyTuplesTypeAssertion01.errors.txt | 3 +- .../reference/emptyTuplesTypeAssertion01.js | 1 - .../emptyTuplesTypeAssertion02.errors.txt | 3 +- .../reference/emptyTuplesTypeAssertion02.js | 1 - ...ariableDeclarationBindingPatterns01_ES5.js | 1 - ...leDeclarationBindingPatterns01_ES5.symbols | 67 +- ...ableDeclarationBindingPatterns01_ES5.types | 1 - ...eclarationBindingPatterns01_ES5iterable.js | 1 - ...ationBindingPatterns01_ES5iterable.symbols | 67 +- ...arationBindingPatterns01_ES5iterable.types | 1 - ...ariableDeclarationBindingPatterns01_ES6.js | 1 - ...leDeclarationBindingPatterns01_ES6.symbols | 67 +- ...ableDeclarationBindingPatterns01_ES6.types | 1 - ...eclarationBindingPatterns02_ES5.errors.txt | 9 +- ...ariableDeclarationBindingPatterns02_ES5.js | 1 - ...onBindingPatterns02_ES5iterable.errors.txt | 9 +- ...eclarationBindingPatterns02_ES5iterable.js | 1 - ...eclarationBindingPatterns02_ES6.errors.txt | 9 +- ...ariableDeclarationBindingPatterns02_ES6.js | 1 - tests/baselines/reference/enumDecl1.js | 1 - tests/baselines/reference/enumDecl1.symbols | 9 +- tests/baselines/reference/enumDecl1.types | 1 - .../baselines/reference/enumLiteralTypes2.js | 1 - .../reference/enumLiteralTypes2.symbols | 417 ++- .../reference/enumLiteralTypes2.types | 1 - .../reference/equalityStrictNulls.errors.txt | 9 +- .../reference/equalityStrictNulls.js | 1 - .../reference/errorSupression1.errors.txt | 3 +- tests/baselines/reference/errorSupression1.js | 1 - .../errorWithTruncatedType.errors.txt | 3 +- .../reference/errorWithTruncatedType.js | 1 - .../errorsInGenericTypeReference.errors.txt | 43 +- .../reference/errorsInGenericTypeReference.js | 1 - .../errorsOnImportedSymbol.errors.txt | 1 - .../reference/errorsOnImportedSymbol.js | 1 - tests/baselines/reference/es2015modulekind.js | 1 - .../reference/es2015modulekind.symbols | 3 +- .../reference/es2015modulekind.types | 1 - .../es2015modulekindWithES6Target.js | 1 - .../es2015modulekindWithES6Target.symbols | 3 +- .../es2015modulekindWithES6Target.types | 1 - tests/baselines/reference/es2017basicAsync.js | 1 - .../reference/es2017basicAsync.symbols | 21 +- .../reference/es2017basicAsync.types | 1 - tests/baselines/reference/es3-amd.js | 1 - tests/baselines/reference/es3-amd.symbols | 3 +- tests/baselines/reference/es3-amd.types | 1 - .../reference/es3-declaration-amd.js | 1 - .../reference/es3-declaration-amd.symbols | 3 +- .../reference/es3-declaration-amd.types | 1 - tests/baselines/reference/es3-jsx-preserve.js | 1 - .../reference/es3-jsx-preserve.symbols | 5 +- .../reference/es3-jsx-preserve.types | 1 - .../reference/es3-jsx-react-native.js | 1 - .../reference/es3-jsx-react-native.symbols | 5 +- .../reference/es3-jsx-react-native.types | 1 - tests/baselines/reference/es3-jsx-react.js | 1 - .../baselines/reference/es3-jsx-react.symbols | 5 +- tests/baselines/reference/es3-jsx-react.types | 1 - .../baselines/reference/es3-sourcemap-amd.js | 1 - .../reference/es3-sourcemap-amd.js.map | 2 +- .../reference/es3-sourcemap-amd.sourcemap.txt | 43 +- .../reference/es3-sourcemap-amd.symbols | 3 +- .../reference/es3-sourcemap-amd.types | 1 - .../reference/es3defaultAliasIsQuoted.js | 1 - .../reference/es3defaultAliasIsQuoted.symbols | 13 +- .../reference/es3defaultAliasIsQuoted.types | 1 - tests/baselines/reference/es5-amd.js | 1 - tests/baselines/reference/es5-amd.symbols | 3 +- tests/baselines/reference/es5-amd.types | 1 - tests/baselines/reference/es5-commonjs.js | 1 - .../baselines/reference/es5-commonjs.symbols | 3 +- tests/baselines/reference/es5-commonjs.types | 1 - tests/baselines/reference/es5-commonjs2.js | 1 - .../baselines/reference/es5-commonjs2.symbols | 3 +- tests/baselines/reference/es5-commonjs2.types | 3 +- .../reference/es5-commonjs3.errors.txt | 3 +- tests/baselines/reference/es5-commonjs3.js | 1 - .../reference/es5-commonjs4.errors.txt | 3 +- tests/baselines/reference/es5-commonjs4.js | 1 - tests/baselines/reference/es5-commonjs5.js | 1 - .../baselines/reference/es5-commonjs5.symbols | 3 +- tests/baselines/reference/es5-commonjs5.types | 1 - tests/baselines/reference/es5-commonjs6.js | 1 - .../baselines/reference/es5-commonjs6.symbols | 3 +- tests/baselines/reference/es5-commonjs6.types | 1 - .../baselines/reference/es5-commonjs7.symbols | 3 +- tests/baselines/reference/es5-commonjs7.types | 1 - .../baselines/reference/es5-commonjs8.symbols | 3 +- tests/baselines/reference/es5-commonjs8.types | 1 - .../reference/es5-declaration-amd.js | 1 - .../reference/es5-declaration-amd.symbols | 3 +- .../reference/es5-declaration-amd.types | 1 - tests/baselines/reference/es5-souremap-amd.js | 1 - .../reference/es5-souremap-amd.js.map | 2 +- .../reference/es5-souremap-amd.sourcemap.txt | 43 +- .../reference/es5-souremap-amd.symbols | 3 +- .../reference/es5-souremap-amd.types | 1 - tests/baselines/reference/es5-system.js | 1 - tests/baselines/reference/es5-system.symbols | 3 +- tests/baselines/reference/es5-system.types | 1 - tests/baselines/reference/es5-system2.js | 1 - tests/baselines/reference/es5-system2.symbols | 3 +- tests/baselines/reference/es5-system2.types | 1 - tests/baselines/reference/es5-umd.js | 1 - tests/baselines/reference/es5-umd.symbols | 3 +- tests/baselines/reference/es5-umd.types | 1 - tests/baselines/reference/es5-umd2.js | 1 - tests/baselines/reference/es5-umd2.symbols | 3 +- tests/baselines/reference/es5-umd2.types | 1 - tests/baselines/reference/es5-umd3.js | 1 - tests/baselines/reference/es5-umd3.symbols | 3 +- tests/baselines/reference/es5-umd3.types | 1 - tests/baselines/reference/es5-umd4.js | 1 - tests/baselines/reference/es5-umd4.symbols | 3 +- tests/baselines/reference/es5-umd4.types | 1 - .../es5ExportDefaultClassDeclaration.js | 1 - .../es5ExportDefaultClassDeclaration.symbols | 3 +- .../es5ExportDefaultClassDeclaration.types | 1 - .../es5ExportDefaultClassDeclaration2.js | 1 - .../es5ExportDefaultClassDeclaration2.symbols | 3 +- .../es5ExportDefaultClassDeclaration2.types | 1 - .../es5ExportDefaultClassDeclaration3.js | 1 - .../es5ExportDefaultClassDeclaration3.symbols | 27 +- .../es5ExportDefaultClassDeclaration3.types | 1 - .../es5ExportDefaultClassDeclaration4.js | 1 - .../es5ExportDefaultClassDeclaration4.symbols | 19 +- .../es5ExportDefaultClassDeclaration4.types | 1 - .../reference/es5ExportDefaultExpression.js | 1 - .../es5ExportDefaultExpression.symbols | 3 +- .../es5ExportDefaultExpression.types | 1 - .../es5ExportDefaultFunctionDeclaration.js | 1 - ...s5ExportDefaultFunctionDeclaration.symbols | 1 - .../es5ExportDefaultFunctionDeclaration.types | 1 - .../es5ExportDefaultFunctionDeclaration2.js | 1 - ...5ExportDefaultFunctionDeclaration2.symbols | 3 +- ...es5ExportDefaultFunctionDeclaration2.types | 3 +- .../es5ExportDefaultFunctionDeclaration3.js | 1 - ...5ExportDefaultFunctionDeclaration3.symbols | 19 +- ...es5ExportDefaultFunctionDeclaration3.types | 1 - .../es5ExportDefaultFunctionDeclaration4.js | 1 - ...5ExportDefaultFunctionDeclaration4.symbols | 13 +- ...es5ExportDefaultFunctionDeclaration4.types | 1 - .../reference/es5ExportDefaultIdentifier.js | 1 - .../es5ExportDefaultIdentifier.symbols | 1 - .../es5ExportDefaultIdentifier.types | 1 - .../reference/es5ExportEquals.errors.txt | 3 +- tests/baselines/reference/es5ExportEquals.js | 1 - .../baselines/reference/es5ExportEqualsDts.js | 1 - .../reference/es5ExportEqualsDts.symbols | 19 +- .../reference/es5ExportEqualsDts.types | 1 - .../es5ModuleInternalNamedImports.errors.txt | 11 +- .../es5ModuleInternalNamedImports.js | 1 - tests/baselines/reference/es5andes6module.js | 1 - .../reference/es5andes6module.symbols | 3 +- .../baselines/reference/es5andes6module.types | 1 - tests/baselines/reference/es6-amd.js | 1 - tests/baselines/reference/es6-amd.symbols | 3 +- tests/baselines/reference/es6-amd.types | 1 - .../reference/es6-declaration-amd.js | 1 - .../reference/es6-declaration-amd.symbols | 3 +- .../reference/es6-declaration-amd.types | 1 - .../baselines/reference/es6-sourcemap-amd.js | 1 - .../reference/es6-sourcemap-amd.js.map | 2 +- .../reference/es6-sourcemap-amd.sourcemap.txt | 31 +- .../reference/es6-sourcemap-amd.symbols | 3 +- .../reference/es6-sourcemap-amd.types | 1 - tests/baselines/reference/es6-umd.js | 1 - tests/baselines/reference/es6-umd.symbols | 3 +- tests/baselines/reference/es6-umd.types | 1 - tests/baselines/reference/es6-umd2.js | 1 - tests/baselines/reference/es6-umd2.symbols | 3 +- tests/baselines/reference/es6-umd2.types | 1 - .../reference/es6ClassSuperCodegenBug.js | 1 - .../reference/es6ClassSuperCodegenBug.symbols | 7 +- .../reference/es6ClassSuperCodegenBug.types | 1 - tests/baselines/reference/es6ExportAll.js | 1 - .../baselines/reference/es6ExportAll.symbols | 11 +- tests/baselines/reference/es6ExportAll.types | 1 - .../baselines/reference/es6ExportAllInEs5.js | 1 - .../reference/es6ExportAllInEs5.symbols | 11 +- .../reference/es6ExportAllInEs5.types | 1 - .../reference/es6ExportAssignment.errors.txt | 3 +- .../reference/es6ExportAssignment.js | 1 - .../reference/es6ExportAssignment2.errors.txt | 3 +- .../reference/es6ExportAssignment2.js | 1 - .../reference/es6ExportAssignment3.js | 1 - .../reference/es6ExportAssignment3.symbols | 5 +- .../reference/es6ExportAssignment3.types | 1 - .../reference/es6ExportAssignment4.js | 1 - .../reference/es6ExportAssignment4.symbols | 5 +- .../reference/es6ExportAssignment4.types | 1 - tests/baselines/reference/es6ExportClause.js | 1 - .../reference/es6ExportClause.symbols | 27 +- .../baselines/reference/es6ExportClause.types | 1 - .../reference/es6ExportClauseInEs5.js | 1 - .../reference/es6ExportClauseInEs5.symbols | 27 +- .../reference/es6ExportClauseInEs5.types | 1 - .../es6ExportClauseWithAssignmentInEs5.js | 1 - ...es6ExportClauseWithAssignmentInEs5.symbols | 33 +- .../es6ExportClauseWithAssignmentInEs5.types | 1 - .../es6ExportClauseWithoutModuleSpecifier.js | 1 - ...ExportClauseWithoutModuleSpecifier.symbols | 11 +- ...s6ExportClauseWithoutModuleSpecifier.types | 1 - ...ExportClauseWithoutModuleSpecifierInEs5.js | 1 - ...tClauseWithoutModuleSpecifierInEs5.symbols | 11 +- ...ortClauseWithoutModuleSpecifierInEs5.types | 1 - .../es6ExportDefaultClassDeclaration.js | 1 - .../es6ExportDefaultClassDeclaration.symbols | 3 +- .../es6ExportDefaultClassDeclaration.types | 1 - .../es6ExportDefaultClassDeclaration2.js | 1 - .../es6ExportDefaultClassDeclaration2.symbols | 3 +- .../es6ExportDefaultClassDeclaration2.types | 1 - .../reference/es6ExportDefaultExpression.js | 1 - .../es6ExportDefaultExpression.symbols | 3 +- .../es6ExportDefaultExpression.types | 1 - .../es6ExportDefaultFunctionDeclaration.js | 1 - ...s6ExportDefaultFunctionDeclaration.symbols | 1 - .../es6ExportDefaultFunctionDeclaration.types | 1 - .../es6ExportDefaultFunctionDeclaration2.js | 1 - ...6ExportDefaultFunctionDeclaration2.symbols | 3 +- ...es6ExportDefaultFunctionDeclaration2.types | 3 +- .../reference/es6ExportDefaultIdentifier.js | 1 - .../es6ExportDefaultIdentifier.symbols | 1 - .../es6ExportDefaultIdentifier.types | 1 - .../reference/es6ExportEquals.errors.txt | 5 +- tests/baselines/reference/es6ExportEquals.js | 1 - .../es6ExportEqualsInterop.errors.txt | 1 - .../reference/es6ExportEqualsInterop.js | 1 - .../reference/es6ImportDefaultBinding.js | 1 - .../reference/es6ImportDefaultBinding.symbols | 5 +- .../reference/es6ImportDefaultBinding.types | 1 - .../reference/es6ImportDefaultBindingAmd.js | 1 - .../es6ImportDefaultBindingAmd.symbols | 5 +- .../es6ImportDefaultBindingAmd.types | 1 - .../reference/es6ImportDefaultBindingDts.js | 1 - .../es6ImportDefaultBindingDts.symbols | 1 - .../es6ImportDefaultBindingDts.types | 1 - ...rtDefaultBindingFollowedWithNamedImport.js | 1 - ...aultBindingFollowedWithNamedImport.symbols | 11 +- ...efaultBindingFollowedWithNamedImport.types | 1 - ...BindingFollowedWithNamedImport1.errors.txt | 1 - ...tDefaultBindingFollowedWithNamedImport1.js | 1 - ...ngFollowedWithNamedImport1InEs5.errors.txt | 1 - ...ultBindingFollowedWithNamedImport1InEs5.js | 1 - ...lowedWithNamedImport1WithExport.errors.txt | 1 - ...ndingFollowedWithNamedImport1WithExport.js | 1 - ...ndingFollowedWithNamedImportDts.errors.txt | 1 - ...efaultBindingFollowedWithNamedImportDts.js | 1 - ...dingFollowedWithNamedImportDts1.errors.txt | 1 - ...faultBindingFollowedWithNamedImportDts1.js | 1 - ...ingFollowedWithNamedImportInEs5.errors.txt | 1 - ...aultBindingFollowedWithNamedImportInEs5.js | 1 - ...llowedWithNamedImportWithExport.errors.txt | 1 - ...indingFollowedWithNamedImportWithExport.js | 1 - ...ingFollowedWithNamespaceBinding.errors.txt | 1 - ...aultBindingFollowedWithNamespaceBinding.js | 1 - ...ultBindingFollowedWithNamespaceBinding1.js | 1 - ...ndingFollowedWithNamespaceBinding1.symbols | 5 +- ...BindingFollowedWithNamespaceBinding1.types | 1 - ...ndingFollowedWithNamespaceBinding1InEs5.js | 1 - ...FollowedWithNamespaceBinding1InEs5.symbols | 5 +- ...ngFollowedWithNamespaceBinding1InEs5.types | 1 - ...WithNamespaceBinding1WithExport.errors.txt | 1 - ...FollowedWithNamespaceBinding1WithExport.js | 1 - ...FollowedWithNamespaceBindingDts.errors.txt | 1 - ...tBindingFollowedWithNamespaceBindingDts.js | 1 - ...BindingFollowedWithNamespaceBindingDts1.js | 1 - ...ngFollowedWithNamespaceBindingDts1.symbols | 1 - ...dingFollowedWithNamespaceBindingDts1.types | 1 - ...llowedWithNamespaceBindingInEs5.errors.txt | 1 - ...indingFollowedWithNamespaceBindingInEs5.js | 1 - ...dWithNamespaceBindingWithExport.errors.txt | 1 - ...gFollowedWithNamespaceBindingWithExport.js | 1 - .../es6ImportDefaultBindingInEs5.errors.txt | 1 - .../reference/es6ImportDefaultBindingInEs5.js | 1 - ...ImportDefaultBindingMergeErrors.errors.txt | 1 - .../es6ImportDefaultBindingMergeErrors.js | 1 - ...DefaultBindingNoDefaultProperty.errors.txt | 1 - ...s6ImportDefaultBindingNoDefaultProperty.js | 1 - ...6ImportDefaultBindingWithExport.errors.txt | 1 - .../es6ImportDefaultBindingWithExport.js | 1 - .../es6ImportEqualsDeclaration.errors.txt | 3 +- .../reference/es6ImportEqualsDeclaration.js | 1 - .../reference/es6ImportEqualsDeclaration2.js | 1 - .../es6ImportEqualsDeclaration2.symbols | 11 +- .../es6ImportEqualsDeclaration2.types | 1 - .../reference/es6ImportNameSpaceImport.js | 1 - .../es6ImportNameSpaceImport.symbols | 7 +- .../reference/es6ImportNameSpaceImport.types | 1 - .../reference/es6ImportNameSpaceImportAmd.js | 1 - .../es6ImportNameSpaceImportAmd.symbols | 7 +- .../es6ImportNameSpaceImportAmd.types | 1 - .../reference/es6ImportNameSpaceImportDts.js | 1 - .../es6ImportNameSpaceImportDts.symbols | 1 - .../es6ImportNameSpaceImportDts.types | 1 - .../es6ImportNameSpaceImportInEs5.js | 1 - .../es6ImportNameSpaceImportInEs5.symbols | 7 +- .../es6ImportNameSpaceImportInEs5.types | 1 - ...mportNameSpaceImportMergeErrors.errors.txt | 1 - .../es6ImportNameSpaceImportMergeErrors.js | 1 - .../es6ImportNameSpaceImportNoNamedExports.js | 1 - ...mportNameSpaceImportNoNamedExports.symbols | 5 +- ...6ImportNameSpaceImportNoNamedExports.types | 1 - ...ImportNameSpaceImportWithExport.errors.txt | 1 - .../es6ImportNameSpaceImportWithExport.js | 1 - .../reference/es6ImportNamedImport.js | 1 - .../reference/es6ImportNamedImport.symbols | 21 +- .../reference/es6ImportNamedImport.types | 1 - .../reference/es6ImportNamedImportAmd.js | 1 - .../reference/es6ImportNamedImportAmd.symbols | 21 +- .../reference/es6ImportNamedImportAmd.types | 1 - .../reference/es6ImportNamedImportDts.js | 1 - .../reference/es6ImportNamedImportDts.symbols | 27 +- .../reference/es6ImportNamedImportDts.types | 1 - ...rtNamedImportIdentifiersParsing.errors.txt | 25 +- .../es6ImportNamedImportIdentifiersParsing.js | 1 - .../reference/es6ImportNamedImportInEs5.js | 1 - .../es6ImportNamedImportInEs5.symbols | 21 +- .../reference/es6ImportNamedImportInEs5.types | 1 - .../es6ImportNamedImportInExportAssignment.js | 1 - ...mportNamedImportInExportAssignment.symbols | 3 +- ...6ImportNamedImportInExportAssignment.types | 1 - ...rtNamedImportInIndirectExportAssignment.js | 1 - ...edImportInIndirectExportAssignment.symbols | 3 +- ...amedImportInIndirectExportAssignment.types | 1 - ...es6ImportNamedImportMergeErrors.errors.txt | 1 - .../es6ImportNamedImportMergeErrors.js | 1 - ...ImportNamedImportNoExportMember.errors.txt | 1 - .../es6ImportNamedImportNoExportMember.js | 1 - ...ImportNamedImportNoNamedExports.errors.txt | 1 - .../es6ImportNamedImportNoNamedExports.js | 1 - ...s6ImportNamedImportParsingError.errors.txt | 1 - .../es6ImportNamedImportParsingError.js | 1 - .../es6ImportNamedImportWithExport.errors.txt | 1 - .../es6ImportNamedImportWithExport.js | 1 - .../es6ImportNamedImportWithTypesAndValues.js | 1 - ...mportNamedImportWithTypesAndValues.symbols | 17 +- ...6ImportNamedImportWithTypesAndValues.types | 1 - .../reference/es6ImportParseErrors.errors.txt | 3 +- .../reference/es6ImportParseErrors.js | 1 - .../reference/es6ImportWithoutFromClause.js | 1 - .../es6ImportWithoutFromClause.symbols | 3 +- .../es6ImportWithoutFromClause.types | 1 - .../es6ImportWithoutFromClauseAmd.js | 1 - .../es6ImportWithoutFromClauseAmd.symbols | 3 +- .../es6ImportWithoutFromClauseAmd.types | 1 - .../es6ImportWithoutFromClauseInEs5.js | 1 - .../es6ImportWithoutFromClauseInEs5.symbols | 3 +- .../es6ImportWithoutFromClauseInEs5.types | 1 - ...tWithoutFromClauseNonInstantiatedModule.js | 1 - ...outFromClauseNonInstantiatedModule.symbols | 1 - ...thoutFromClauseNonInstantiatedModule.types | 1 - ...portWithoutFromClauseWithExport.errors.txt | 1 - .../es6ImportWithoutFromClauseWithExport.js | 1 - .../reference/es6MemberScoping.errors.txt | 4 +- tests/baselines/reference/es6MemberScoping.js | 2 - .../es6ModuleConstEnumDeclaration2.js | 1 - .../es6ModuleConstEnumDeclaration2.symbols | 137 +- .../es6ModuleConstEnumDeclaration2.types | 1 - .../es6ModuleInternalNamedImports.errors.txt | 3 +- .../es6ModuleInternalNamedImports.js | 1 - .../es6ModuleInternalNamedImports2.errors.txt | 3 +- .../es6ModuleInternalNamedImports2.js | 1 - .../reference/es6UseOfTopLevelRequire.js | 1 - .../reference/es6UseOfTopLevelRequire.symbols | 3 +- .../reference/es6UseOfTopLevelRequire.types | 1 - tests/baselines/reference/es6modulekind.js | 1 - .../baselines/reference/es6modulekind.symbols | 3 +- tests/baselines/reference/es6modulekind.types | 1 - .../es6modulekindWithES2015Target.js | 1 - .../es6modulekindWithES2015Target.symbols | 3 +- .../es6modulekindWithES2015Target.types | 1 - .../reference/es6modulekindWithES5Target.js | 1 - .../es6modulekindWithES5Target.symbols | 33 +- .../es6modulekindWithES5Target.types | 1 - .../es6modulekindWithES5Target10.errors.txt | 7 +- .../reference/es6modulekindWithES5Target10.js | 1 - .../reference/es6modulekindWithES5Target11.js | 1 - .../es6modulekindWithES5Target11.symbols | 19 +- .../es6modulekindWithES5Target11.types | 1 - .../reference/es6modulekindWithES5Target12.js | 1 - .../es6modulekindWithES5Target12.symbols | 35 +- .../es6modulekindWithES5Target12.types | 1 - .../reference/es6modulekindWithES5Target2.js | 1 - .../es6modulekindWithES5Target2.symbols | 7 +- .../es6modulekindWithES5Target2.types | 1 - .../reference/es6modulekindWithES5Target3.js | 2 - .../es6modulekindWithES5Target3.symbols | 12 +- .../es6modulekindWithES5Target3.types | 2 - .../reference/es6modulekindWithES5Target4.js | 1 - .../es6modulekindWithES5Target4.symbols | 1 - .../es6modulekindWithES5Target4.types | 1 - .../reference/es6modulekindWithES5Target5.js | 1 - .../es6modulekindWithES5Target5.symbols | 7 +- .../es6modulekindWithES5Target5.types | 1 - .../reference/es6modulekindWithES5Target6.js | 1 - .../es6modulekindWithES5Target6.symbols | 11 +- .../es6modulekindWithES5Target6.types | 1 - .../reference/es6modulekindWithES5Target7.js | 1 - .../es6modulekindWithES5Target7.symbols | 7 +- .../es6modulekindWithES5Target7.types | 1 - .../reference/es6modulekindWithES5Target8.js | 1 - .../es6modulekindWithES5Target8.symbols | 5 +- .../es6modulekindWithES5Target8.types | 1 - .../es6modulekindWithES5Target9.errors.txt | 11 +- .../reference/es6modulekindWithES5Target9.js | 1 - .../baselines/reference/escapedIdentifiers.js | 1 - .../reference/escapedIdentifiers.symbols | 207 +- .../reference/escapedIdentifiers.types | 1 - .../excessPropertyErrorsSuppressed.js | 1 - .../excessPropertyErrorsSuppressed.symbols | 9 +- .../excessPropertyErrorsSuppressed.types | 1 - ...xhaustiveSwitchWithWideningLiteralTypes.js | 1 - ...tiveSwitchWithWideningLiteralTypes.symbols | 19 +- ...ustiveSwitchWithWideningLiteralTypes.types | 1 - ...nTemplateStringWithSyntaxError1.errors.txt | 69 +- ...peratorInTemplateStringWithSyntaxError1.js | 1 - ...nTemplateStringWithSyntaxError2.errors.txt | 69 +- ...peratorInTemplateStringWithSyntaxError2.js | 1 - ...nTemplateStringWithSyntaxError3.errors.txt | 69 +- ...peratorInTemplateStringWithSyntaxError3.js | 1 - ...onentiationOperatorSyntaxError1.errors.txt | 35 +- .../exponentiationOperatorSyntaxError1.js | 4 +- ...onentiationOperatorSyntaxError2.errors.txt | 43 +- .../exponentiationOperatorSyntaxError2.js | 1 - ...eratorWithTemplateStringInvalid.errors.txt | 7 +- ...iationOperatorWithTemplateStringInvalid.js | 1 - ...torWithTemplateStringInvalidES6.errors.txt | 11 +- ...ionOperatorWithTemplateStringInvalidES6.js | 1 - .../reference/exportAndImport-es3-amd.js | 1 - .../reference/exportAndImport-es3-amd.symbols | 1 - .../reference/exportAndImport-es3-amd.types | 1 - .../reference/exportAndImport-es3.js | 1 - .../reference/exportAndImport-es3.symbols | 1 - .../reference/exportAndImport-es3.types | 1 - .../reference/exportAndImport-es5-amd.js | 1 - .../reference/exportAndImport-es5-amd.symbols | 1 - .../reference/exportAndImport-es5-amd.types | 1 - .../reference/exportAndImport-es5.js | 1 - .../reference/exportAndImport-es5.symbols | 1 - .../reference/exportAndImport-es5.types | 1 - .../exportAssignedTypeAsTypeAnnotation.js | 1 - ...exportAssignedTypeAsTypeAnnotation.symbols | 3 +- .../exportAssignedTypeAsTypeAnnotation.types | 1 - tests/baselines/reference/exportCodeGen.js | 1 - .../baselines/reference/exportCodeGen.symbols | 63 +- tests/baselines/reference/exportCodeGen.types | 1 - ...portDeclarationInInternalModule.errors.txt | 3 +- .../exportDeclarationInInternalModule.js | 1 - ...ationWithModuleSpecifierNameOnNextLine1.js | 1 - ...WithModuleSpecifierNameOnNextLine1.symbols | 3 +- ...onWithModuleSpecifierNameOnNextLine1.types | 1 - .../exportDeclarationsInAmbientNamespaces.js | 1 - ...ortDeclarationsInAmbientNamespaces.symbols | 15 +- ...xportDeclarationsInAmbientNamespaces.types | 1 - ...eclarationsInAmbientNamespaces2.errors.txt | 3 +- .../exportDeclarationsInAmbientNamespaces2.js | 1 - .../reference/exportDeclaredModule.js | 1 - .../reference/exportDeclaredModule.symbols | 9 +- .../reference/exportDeclaredModule.types | 1 - .../reference/exportDefaultAsyncFunction2.js | 1 - .../exportDefaultAsyncFunction2.symbols | 9 +- .../exportDefaultAsyncFunction2.types | 1 - .../exportDefaultForNonInstantiatedModule.js | 1 - ...ortDefaultForNonInstantiatedModule.symbols | 3 +- ...xportDefaultForNonInstantiatedModule.types | 1 - .../exportDefaultInJsFile01.errors.txt | 1 - .../exportDefaultInJsFile02.errors.txt | 1 - .../reference/exportEqualCallable.js | 1 - .../reference/exportEqualCallable.symbols | 5 +- .../reference/exportEqualCallable.types | 1 - .../reference/exportEqualsDefaultProperty.js | 1 - .../exportEqualsDefaultProperty.symbols | 5 +- .../exportEqualsDefaultProperty.types | 1 - tests/baselines/reference/exportImport.js | 1 - .../baselines/reference/exportImport.symbols | 7 +- tests/baselines/reference/exportImport.types | 1 - .../exportImportNonInstantiatedModule2.js | 1 - ...exportImportNonInstantiatedModule2.symbols | 7 +- .../exportImportNonInstantiatedModule2.types | 1 - ...xportNonInitializedVariablesAMD.errors.txt | 9 +- .../exportNonInitializedVariablesAMD.js | 1 - ...NonInitializedVariablesCommonJS.errors.txt | 9 +- .../exportNonInitializedVariablesCommonJS.js | 1 - ...xportNonInitializedVariablesES6.errors.txt | 9 +- .../exportNonInitializedVariablesES6.js | 1 - ...rtNonInitializedVariablesSystem.errors.txt | 9 +- .../exportNonInitializedVariablesSystem.js | 1 - ...xportNonInitializedVariablesUMD.errors.txt | 9 +- .../exportNonInitializedVariablesUMD.js | 1 - .../exportSpecifierForAGlobal.errors.txt | 1 - .../reference/exportSpecifierForAGlobal.js | 1 - .../reference/exportStar-amd.errors.txt | 1 - tests/baselines/reference/exportStar-amd.js | 1 - .../baselines/reference/exportStar.errors.txt | 1 - tests/baselines/reference/exportStar.js | 1 - .../reference/exportStarForValues.js | 1 - .../reference/exportStarForValues.symbols | 3 +- .../reference/exportStarForValues.types | 1 - .../reference/exportStarForValues10.js | 1 - .../reference/exportStarForValues10.symbols | 3 +- .../reference/exportStarForValues10.types | 1 - .../reference/exportStarForValues2.js | 1 - .../reference/exportStarForValues2.symbols | 3 +- .../reference/exportStarForValues2.types | 1 - .../reference/exportStarForValues3.js | 1 - .../reference/exportStarForValues3.symbols | 3 +- .../reference/exportStarForValues3.types | 1 - .../reference/exportStarForValues4.js | 1 - .../reference/exportStarForValues4.symbols | 3 +- .../reference/exportStarForValues4.types | 1 - .../reference/exportStarForValues5.js | 1 - .../reference/exportStarForValues5.symbols | 3 +- .../reference/exportStarForValues5.types | 1 - .../reference/exportStarForValues6.js | 1 - .../reference/exportStarForValues6.symbols | 3 +- .../reference/exportStarForValues6.types | 1 - .../reference/exportStarForValues7.js | 1 - .../reference/exportStarForValues7.symbols | 3 +- .../reference/exportStarForValues7.types | 1 - .../reference/exportStarForValues8.js | 1 - .../reference/exportStarForValues8.symbols | 3 +- .../reference/exportStarForValues8.types | 1 - .../reference/exportStarForValues9.js | 1 - .../reference/exportStarForValues9.symbols | 3 +- .../reference/exportStarForValues9.types | 1 - .../reference/exportStarForValuesInSystem.js | 1 - .../exportStarForValuesInSystem.symbols | 3 +- .../exportStarForValuesInSystem.types | 1 - .../exportStarFromEmptyModule.errors.txt | 1 - .../reference/exportStarFromEmptyModule.js | 1 - .../reference/exportsAndImports1-amd.js | 1 - .../reference/exportsAndImports1-amd.symbols | 61 +- .../reference/exportsAndImports1-amd.types | 1 - .../reference/exportsAndImports1-es6.js | 1 - .../reference/exportsAndImports1-es6.symbols | 61 +- .../reference/exportsAndImports1-es6.types | 1 - .../baselines/reference/exportsAndImports1.js | 1 - .../reference/exportsAndImports1.symbols | 61 +- .../reference/exportsAndImports1.types | 1 - .../reference/exportsAndImports2-amd.js | 1 - .../reference/exportsAndImports2-amd.symbols | 5 +- .../reference/exportsAndImports2-amd.types | 1 - .../reference/exportsAndImports2-es6.js | 1 - .../reference/exportsAndImports2-es6.symbols | 5 +- .../reference/exportsAndImports2-es6.types | 1 - .../baselines/reference/exportsAndImports2.js | 1 - .../reference/exportsAndImports2.symbols | 5 +- .../reference/exportsAndImports2.types | 1 - .../reference/exportsAndImports3-amd.js | 1 - .../reference/exportsAndImports3-amd.symbols | 81 +- .../reference/exportsAndImports3-amd.types | 1 - .../reference/exportsAndImports3-es6.js | 1 - .../reference/exportsAndImports3-es6.symbols | 81 +- .../reference/exportsAndImports3-es6.types | 1 - .../baselines/reference/exportsAndImports3.js | 1 - .../reference/exportsAndImports3.symbols | 81 +- .../reference/exportsAndImports3.types | 1 - .../reference/exportsAndImports4-amd.js | 1 - .../reference/exportsAndImports4-amd.symbols | 3 +- .../reference/exportsAndImports4-amd.types | 3 +- .../reference/exportsAndImports4-es6.js | 1 - .../reference/exportsAndImports4-es6.symbols | 3 +- .../reference/exportsAndImports4-es6.types | 3 +- .../baselines/reference/exportsAndImports4.js | 1 - .../reference/exportsAndImports4.symbols | 3 +- .../reference/exportsAndImports4.types | 3 +- ...rtsWithContextualKeywordNames01.errors.txt | 1 - ...sAndImportsWithContextualKeywordNames01.js | 1 - ...sAndImportsWithContextualKeywordNames02.js | 1 - ...mportsWithContextualKeywordNames02.symbols | 17 +- ...dImportsWithContextualKeywordNames02.types | 1 - ...portsAndImportsWithUnderscores1.errors.txt | 3 +- .../exportsAndImportsWithUnderscores1.js | 1 - .../exportsAndImportsWithUnderscores2.js | 1 - .../exportsAndImportsWithUnderscores2.symbols | 5 +- .../exportsAndImportsWithUnderscores2.types | 1 - .../exportsAndImportsWithUnderscores3.js | 1 - .../exportsAndImportsWithUnderscores3.symbols | 5 +- .../exportsAndImportsWithUnderscores3.types | 1 - .../exportsAndImportsWithUnderscores4.js | 1 - .../exportsAndImportsWithUnderscores4.symbols | 31 +- .../exportsAndImportsWithUnderscores4.types | 1 - .../reference/exportsInAmbientModules1.js | 2 - .../exportsInAmbientModules1.symbols | 6 +- .../reference/exportsInAmbientModules1.types | 2 - .../reference/exportsInAmbientModules2.js | 2 - .../exportsInAmbientModules2.symbols | 4 +- .../reference/exportsInAmbientModules2.types | 4 +- ...rnalModuleExportingGenericClass.errors.txt | 1 - .../externalModuleExportingGenericClass.js | 1 - ...externalModuleImmutableBindings.errors.txt | 21 +- .../externalModuleImmutableBindings.js | 1 - .../externalModuleWithoutCompilerFlag1.js | 1 - ...externalModuleWithoutCompilerFlag1.symbols | 1 - .../externalModuleWithoutCompilerFlag1.types | 1 - .../baselines/reference/fallFromLastCase1.js | 1 - .../reference/fallFromLastCase1.symbols | 15 +- .../reference/fallFromLastCase1.types | 1 - .../reference/fallFromLastCase2.errors.txt | 5 +- .../baselines/reference/fallFromLastCase2.js | 1 - .../baselines/reference/fatarrowfunctions.js | 1 - .../reference/fatarrowfunctions.symbols | 185 +- .../reference/fatarrowfunctions.types | 1 - tests/baselines/reference/flowInFinally1.js | 1 - .../reference/flowInFinally1.symbols | 15 +- .../baselines/reference/flowInFinally1.types | 1 - .../for-inStatementsArrayErrors.errors.txt | 13 +- .../reference/for-inStatementsArrayErrors.js | 1 - tests/baselines/reference/for.errors.txt | 3 +- tests/baselines/reference/for.js | 1 - .../baselines/reference/forBreakStatements.js | 1 - .../reference/forBreakStatements.symbols | 3 +- .../reference/forBreakStatements.types | 1 - .../reference/forContinueStatements.js | 1 - .../reference/forContinueStatements.symbols | 3 +- .../reference/forContinueStatements.types | 1 - .../reference/forInBreakStatements.js | 1 - .../reference/forInBreakStatements.symbols | 25 +- .../reference/forInBreakStatements.types | 1 - .../reference/forInContinueStatements.js | 1 - .../reference/forInContinueStatements.symbols | 25 +- .../reference/forInContinueStatements.types | 1 - tests/baselines/reference/forStatements.js | 1 - .../baselines/reference/forStatements.symbols | 131 +- tests/baselines/reference/forStatements.types | 1 - ...orStatementsMultipleInvalidDecl.errors.txt | 25 +- .../forStatementsMultipleInvalidDecl.js | 1 - .../forStatementsMultipleValidDecl.js | 1 - .../forStatementsMultipleValidDecl.symbols | 103 +- .../forStatementsMultipleValidDecl.types | 1 - .../reference/functionCalls.errors.txt | 7 +- tests/baselines/reference/functionCalls.js | 1 - .../functionImplementationErrors.errors.txt | 7 +- .../reference/functionImplementationErrors.js | 1 - .../reference/functionImplementations.js | 1 - .../reference/functionImplementations.symbols | 245 +- .../reference/functionImplementations.types | 1 - .../reference/functionOverloads12.js | 1 - .../reference/functionOverloads12.symbols | 7 +- .../reference/functionOverloads12.types | 1 - tests/baselines/reference/functionReturn.js | 1 - .../reference/functionReturn.symbols | 13 +- .../baselines/reference/functionReturn.types | 1 - ...functionTypesLackingReturnTypes.errors.txt | 5 +- .../functionTypesLackingReturnTypes.js | 1 - .../functionWithMultipleReturnStatements.js | 1 - ...nctionWithMultipleReturnStatements.symbols | 55 +- ...functionWithMultipleReturnStatements.types | 1 - .../functionWithMultipleReturnStatements2.js | 1 - ...ctionWithMultipleReturnStatements2.symbols | 55 +- ...unctionWithMultipleReturnStatements2.types | 1 - .../functionWithNoBestCommonType1.js | 1 - .../functionWithNoBestCommonType1.symbols | 5 +- .../functionWithNoBestCommonType1.types | 1 - .../functionWithNoBestCommonType2.js | 1 - .../functionWithNoBestCommonType2.symbols | 7 +- .../functionWithNoBestCommonType2.types | 1 - ...gReturnStatementsAndExpressions.errors.txt | 12 +- ...nsMissingReturnStatementsAndExpressions.js | 2 - .../reference/generatedContextualTyping.js | 1 - .../generatedContextualTyping.symbols | 3327 ++++++++--------- .../reference/generatedContextualTyping.types | 1 - .../reference/generatorTypeCheck47.errors.txt | 3 +- .../reference/generatorTypeCheck47.js | 1 - .../reference/generatorTypeCheck48.errors.txt | 3 +- .../reference/generatorTypeCheck48.js | 1 - .../reference/generatorTypeCheck49.js | 1 - .../reference/generatorTypeCheck49.symbols | 1 - .../reference/generatorTypeCheck49.types | 1 - .../reference/generatorTypeCheck50.js | 1 - .../reference/generatorTypeCheck50.symbols | 1 - .../reference/generatorTypeCheck50.types | 1 - .../reference/generatorTypeCheck51.errors.txt | 3 +- .../reference/generatorTypeCheck51.js | 1 - tests/baselines/reference/genericArray0.js | 1 - .../baselines/reference/genericArray0.symbols | 15 +- tests/baselines/reference/genericArray0.types | 1 - ...edMethodWithOverloadedArguments.errors.txt | 9 +- ...OverloadedMethodWithOverloadedArguments.js | 1 - .../reference/genericClassesInModule.js | 1 - .../reference/genericClassesInModule.symbols | 15 +- .../reference/genericClassesInModule.types | 1 - .../genericDefaultsErrors.errors.txt | 37 +- .../reference/genericDefaultsErrors.js | 1 - tests/baselines/reference/giant.errors.txt | 519 ++- tests/baselines/reference/giant.js | 1 - .../globalAugmentationModuleResolution.js | 1 - ...globalAugmentationModuleResolution.symbols | 5 +- .../globalAugmentationModuleResolution.types | 1 - .../reference/ifDoWhileStatements.js | 1 - .../reference/ifDoWhileStatements.symbols | 209 +- .../reference/ifDoWhileStatements.types | 1 - .../ifElseWithStatements1.errors.txt | 5 +- .../reference/ifElseWithStatements1.js | 1 - .../reference/implicitAnyAmbients.errors.txt | 19 +- .../reference/implicitAnyAmbients.js | 1 - ...mplicitAnyFromCircularInference.errors.txt | 23 +- .../implicitAnyFromCircularInference.js | 1 - ...implicitAnyGenericTypeInference.errors.txt | 5 +- .../implicitAnyGenericTypeInference.js | 1 - .../reference/implicitAnyGenerics.js | 1 - .../reference/implicitAnyGenerics.symbols | 55 +- .../reference/implicitAnyGenerics.types | 1 - .../implicitConstParameters.errors.txt | 5 +- .../reference/implicitConstParameters.js | 1 - .../importHelpersInAmbientContext.js | 1 - .../importHelpersInAmbientContext.symbols | 29 +- .../importHelpersInAmbientContext.types | 1 - .../reference/importShadowsGlobalName.js | 1 - .../reference/importShadowsGlobalName.symbols | 1 - .../reference/importShadowsGlobalName.types | 1 - .../reference/importWithTrailingSlash.js | 1 - .../reference/importWithTrailingSlash.symbols | 11 +- .../reference/importWithTrailingSlash.types | 1 - ...portWithTrailingSlash_noResolve.errors.txt | 3 +- .../importWithTrailingSlash_noResolve.js | 1 - ...ar-referencing-an-imported-module-alias.js | 1 - ...ferencing-an-imported-module-alias.symbols | 7 +- ...referencing-an-imported-module-alias.types | 1 - .../importsImplicitlyReadonly.errors.txt | 1 - .../reference/importsImplicitlyReadonly.js | 1 - .../reference/importsInAmbientModules1.js | 2 - .../importsInAmbientModules1.symbols | 6 +- .../reference/importsInAmbientModules1.types | 2 - .../reference/importsInAmbientModules2.js | 2 - .../importsInAmbientModules2.symbols | 4 +- .../reference/importsInAmbientModules2.types | 2 - .../reference/importsInAmbientModules3.js | 2 - .../importsInAmbientModules3.symbols | 4 +- .../reference/importsInAmbientModules3.types | 2 - .../incompatibleGenericTypes.errors.txt | 3 +- .../reference/incompatibleGenericTypes.js | 1 - ...ypingWithFunctionTypeSyntacticScenarios.js | 1 - ...WithFunctionTypeSyntacticScenarios.symbols | 89 +- ...ngWithFunctionTypeSyntacticScenarios.types | 1 - .../inferredFunctionReturnTypeIsEmptyType.js | 1 - ...erredFunctionReturnTypeIsEmptyType.symbols | 1 - ...nferredFunctionReturnTypeIsEmptyType.types | 1 - ...taticPropertyOverridingAccessor.errors.txt | 5 +- ...ritanceStaticPropertyOverridingAccessor.js | 1 - .../inheritedGenericCallSignature.js | 1 - .../inheritedGenericCallSignature.symbols | 31 +- .../inheritedGenericCallSignature.types | 1 - .../initializePropertiesWithRenamedLet.js | 1 - ...initializePropertiesWithRenamedLet.symbols | 43 +- .../initializePropertiesWithRenamedLet.types | 1 - .../initializersInDeclarations.errors.txt | 13 +- .../reference/inlineSourceMap.errors.txt | 3 +- tests/baselines/reference/inlineSourceMap.js | 3 +- .../reference/inlineSourceMap.sourcemap.txt | 35 +- .../reference/inlineSourceMap2.errors.txt | 3 +- tests/baselines/reference/inlineSourceMap2.js | 3 +- .../reference/inlineSourceMap2.sourcemap.txt | 39 +- .../reference/inlineSources.errors.txt | 3 +- tests/baselines/reference/inlineSources.js | 1 - .../baselines/reference/inlineSources.js.map | 2 +- .../reference/inlineSources.sourcemap.txt | 33 +- .../reference/inlineSources2.errors.txt | 3 +- tests/baselines/reference/inlineSources2.js | 3 +- .../reference/inlineSources2.sourcemap.txt | 37 +- tests/baselines/reference/innerOverloads.js | 1 - .../reference/innerOverloads.symbols | 19 +- .../baselines/reference/innerOverloads.types | 1 - .../reference/instantiatedTypeAliasDisplay.js | 1 - .../instantiatedTypeAliasDisplay.symbols | 75 +- .../instantiatedTypeAliasDisplay.types | 1 - .../interfaceExtendingClass2.errors.txt | 9 +- .../reference/interfaceExtendingClass2.js | 1 - .../interfaceExtendsObjectIntersection.js | 1 - ...interfaceExtendsObjectIntersection.symbols | 251 +- .../interfaceExtendsObjectIntersection.types | 1 - ...ExtendsObjectIntersectionErrors.errors.txt | 47 +- ...nterfaceExtendsObjectIntersectionErrors.js | 1 - .../interfaceWithOptionalProperty.js | 1 - .../interfaceWithOptionalProperty.symbols | 3 +- .../interfaceWithOptionalProperty.types | 1 - .../interfaceWithPrivateMember.errors.txt | 7 +- .../reference/interfaceWithPrivateMember.js | 1 - .../baselines/reference/intrinsics.errors.txt | 7 +- tests/baselines/reference/intrinsics.js | 1 - .../invalidDoWhileBreakStatements.errors.txt | 13 +- .../invalidDoWhileBreakStatements.js | 1 - ...nvalidDoWhileContinueStatements.errors.txt | 13 +- .../invalidDoWhileContinueStatements.js | 1 - .../invalidForBreakStatements.errors.txt | 13 +- .../reference/invalidForBreakStatements.js | 1 - .../invalidForContinueStatements.errors.txt | 13 +- .../reference/invalidForContinueStatements.js | 1 - .../invalidForInBreakStatements.errors.txt | 13 +- .../reference/invalidForInBreakStatements.js | 1 - .../invalidForInContinueStatements.errors.txt | 13 +- .../invalidForInContinueStatements.js | 1 - .../invalidThrowStatement.errors.txt | 5 +- .../reference/invalidThrowStatement.js | 1 - .../invalidWhileContinueStatements.errors.txt | 13 +- .../invalidWhileContinueStatements.js | 1 - .../isDeclarationVisibleNodeKinds.js | 1 - .../isDeclarationVisibleNodeKinds.symbols | 139 +- .../isDeclarationVisibleNodeKinds.types | 1 - ...isolatedModulesAmbientConstEnum.errors.txt | 4 +- .../isolatedModulesAmbientConstEnum.js | 2 - .../isolatedModulesDeclaration.errors.txt | 1 - .../reference/isolatedModulesDeclaration.js | 1 - ...latedModulesImportExportElision.errors.txt | 9 +- .../isolatedModulesImportExportElision.js | 1 - .../isolatedModulesNoEmitOnError.errors.txt | 1 - ...isolatedModulesNoExternalModule.errors.txt | 3 +- .../isolatedModulesNoExternalModule.js | 1 - .../isolatedModulesNonAmbientConstEnum.js | 1 - ...isolatedModulesNonAmbientConstEnum.symbols | 11 +- .../isolatedModulesNonAmbientConstEnum.types | 1 - .../reference/isolatedModulesOut.errors.txt | 3 +- .../baselines/reference/isolatedModulesOut.js | 1 - .../isolatedModulesPlainFile-AMD.errors.txt | 3 +- .../reference/isolatedModulesPlainFile-AMD.js | 1 - ...olatedModulesPlainFile-CommonJS.errors.txt | 3 +- .../isolatedModulesPlainFile-CommonJS.js | 1 - .../isolatedModulesPlainFile-ES6.errors.txt | 3 +- .../reference/isolatedModulesPlainFile-ES6.js | 1 - ...isolatedModulesPlainFile-System.errors.txt | 3 +- .../isolatedModulesPlainFile-System.js | 1 - .../isolatedModulesPlainFile-UMD.errors.txt | 3 +- .../reference/isolatedModulesPlainFile-UMD.js | 1 - .../reference/isolatedModulesSourceMap.js | 1 - .../reference/isolatedModulesSourceMap.js.map | 2 +- .../isolatedModulesSourceMap.sourcemap.txt | 19 +- .../isolatedModulesSourceMap.symbols | 3 +- .../reference/isolatedModulesSourceMap.types | 1 - .../isolatedModulesWithDeclarationFile.js | 1 - ...isolatedModulesWithDeclarationFile.symbols | 1 - .../isolatedModulesWithDeclarationFile.types | 1 - .../isomorphicMappedTypeInference.js | 1 - .../isomorphicMappedTypeInference.symbols | 523 ++- .../isomorphicMappedTypeInference.types | 1 - .../reference/iteratorsAndStrictNullChecks.js | 1 - .../iteratorsAndStrictNullChecks.symbols | 13 +- .../iteratorsAndStrictNullChecks.types | 1 - .../jsFileClassPropertyType.errors.txt | 4 +- .../jsFileClassPropertyType2.errors.txt | 4 +- .../jsFileClassPropertyType3.errors.txt | 4 +- .../jsFileClassSelfReferencedProperty.symbols | 9 +- .../jsFileClassSelfReferencedProperty.types | 1 - ...ationClassMethodContainingArrowFunction.js | 1 - ...ClassMethodContainingArrowFunction.symbols | 15 +- ...onClassMethodContainingArrowFunction.types | 1 - ...ileCompilationExternalPackageError.symbols | 9 +- ...sFileCompilationExternalPackageError.types | 1 - .../jsFileCompilationLetBeingRenamed.js | 1 - .../jsFileCompilationLetBeingRenamed.symbols | 9 +- .../jsFileCompilationLetBeingRenamed.types | 1 - ...jsFileCompilationRestParamJsDocFunction.js | 1 - ...eCompilationRestParamJsDocFunction.symbols | 47 +- ...ileCompilationRestParamJsDocFunction.types | 1 - .../jsFileCompilationShortHandProperty.js | 1 - ...jsFileCompilationShortHandProperty.symbols | 9 +- .../jsFileCompilationShortHandProperty.types | 1 - ...sFileCompilationWithMapFileAsJs.errors.txt | 1 - .../jsFileCompilationWithMapFileAsJs.js | 1 - .../jsFileCompilationWithMapFileAsJs.js.map | 2 +- ...leCompilationWithMapFileAsJs.sourcemap.txt | 23 +- ...hMapFileAsJsWithInlineSourceMap.errors.txt | 1 - ...ationWithMapFileAsJsWithInlineSourceMap.js | 3 +- ...pFileAsJsWithInlineSourceMap.sourcemap.txt | 27 +- ...lationWithMapFileAsJsWithOutDir.errors.txt | 1 - ...ileCompilationWithMapFileAsJsWithOutDir.js | 1 - ...ompilationWithMapFileAsJsWithOutDir.js.map | 2 +- ...ionWithMapFileAsJsWithOutDir.sourcemap.txt | 23 +- ...jsFileFunctionParametersAsOptional.symbols | 7 +- .../jsFileFunctionParametersAsOptional.types | 1 - ...leFunctionParametersAsOptional2.errors.txt | 1 - tests/baselines/reference/json.stringify.js | 1 - .../reference/json.stringify.symbols | 15 +- .../baselines/reference/json.stringify.types | 1 - .../reference/jsxAndTypeAssertion.errors.txt | 29 +- .../reference/jsxAndTypeAssertion.js | 1 - ...AttributeWithoutExpressionReact.errors.txt | 15 +- .../jsxAttributeWithoutExpressionReact.js | 1 - .../reference/jsxEmitAttributeWithPreserve.js | 1 - .../jsxEmitAttributeWithPreserve.symbols | 5 +- .../jsxEmitAttributeWithPreserve.types | 1 - .../reference/jsxEmitWithAttributes.js | 1 - .../reference/jsxEmitWithAttributes.symbols | 57 +- .../reference/jsxEmitWithAttributes.types | 1 - .../jsxFactoryAndReactNamespace.errors.txt | 1 - .../reference/jsxFactoryAndReactNamespace.js | 1 - .../reference/jsxFactoryIdentifier.js | 1 - .../reference/jsxFactoryIdentifier.js.map | 2 +- .../jsxFactoryIdentifier.sourcemap.txt | 161 +- .../reference/jsxFactoryIdentifier.symbols | 61 +- .../reference/jsxFactoryIdentifier.types | 1 - .../jsxFactoryIdentifierAsParameter.js | 1 - .../jsxFactoryIdentifierAsParameter.js.map | 2 +- ...FactoryIdentifierAsParameter.sourcemap.txt | 33 +- .../jsxFactoryIdentifierAsParameter.symbols | 11 +- .../jsxFactoryIdentifierAsParameter.types | 1 - ...ryIdentifierWithAbsentParameter.errors.txt | 3 +- ...jsxFactoryIdentifierWithAbsentParameter.js | 1 - ...actoryIdentifierWithAbsentParameter.js.map | 2 +- ...dentifierWithAbsentParameter.sourcemap.txt | 29 +- ...oryNotIdentifierOrQualifiedName.errors.txt | 1 - .../jsxFactoryNotIdentifierOrQualifiedName.js | 1 - ...ryNotIdentifierOrQualifiedName2.errors.txt | 1 - ...jsxFactoryNotIdentifierOrQualifiedName2.js | 1 - .../reference/jsxFactoryQualifiedName.js | 1 - .../reference/jsxFactoryQualifiedName.js.map | 2 +- .../jsxFactoryQualifiedName.sourcemap.txt | 161 +- .../reference/jsxFactoryQualifiedName.symbols | 57 +- .../reference/jsxFactoryQualifiedName.types | 1 - ...oryQualifiedNameResolutionError.errors.txt | 3 +- .../jsxFactoryQualifiedNameResolutionError.js | 1 - ...FactoryQualifiedNameResolutionError.js.map | 2 +- ...QualifiedNameResolutionError.sourcemap.txt | 33 +- .../jsxFactoryQualifiedNameWithEs5.js | 1 - .../jsxFactoryQualifiedNameWithEs5.symbols | 13 +- .../jsxFactoryQualifiedNameWithEs5.types | 1 - .../reference/jsxImportInAttribute.js | 1 - .../reference/jsxImportInAttribute.symbols | 3 +- .../reference/jsxImportInAttribute.types | 1 - .../reference/jsxParsingError1.errors.txt | 7 +- tests/baselines/reference/jsxParsingError1.js | 1 - .../reference/jsxParsingError2.errors.txt | 1 - tests/baselines/reference/jsxParsingError2.js | 1 - .../reference/jsxPreserveWithJsInput.js | 1 - .../reference/jsxPreserveWithJsInput.symbols | 3 +- .../reference/jsxPreserveWithJsInput.types | 1 - .../baselines/reference/jsxReactTestSuite.js | 1 - .../reference/jsxReactTestSuite.symbols | 135 +- .../reference/jsxReactTestSuite.types | 1 - tests/baselines/reference/jsxViaImport.2.js | 1 - .../reference/jsxViaImport.2.symbols | 25 +- .../baselines/reference/jsxViaImport.2.types | 1 - .../reference/jsxViaImport.errors.txt | 1 - tests/baselines/reference/jsxViaImport.js | 1 - .../baselines/reference/keepImportsInDts1.js | 1 - .../reference/keepImportsInDts1.symbols | 3 +- .../reference/keepImportsInDts1.types | 3 +- .../baselines/reference/keepImportsInDts2.js | 1 - .../reference/keepImportsInDts2.symbols | 3 +- .../reference/keepImportsInDts2.types | 3 +- .../baselines/reference/keepImportsInDts3.js | 1 - .../reference/keepImportsInDts3.symbols | 3 +- .../reference/keepImportsInDts3.types | 3 +- .../baselines/reference/keepImportsInDts4.js | 1 - .../reference/keepImportsInDts4.symbols | 3 +- .../reference/keepImportsInDts4.types | 3 +- tests/baselines/reference/keyofAndForIn.js | 1 - .../baselines/reference/keyofAndForIn.symbols | 147 +- tests/baselines/reference/keyofAndForIn.types | 1 - .../reference/keyofAndIndexedAccess.js | 1 - .../reference/keyofAndIndexedAccess.symbols | 2191 ++++++----- .../reference/keyofAndIndexedAccess.types | 1 - .../reference/keywordInJsxIdentifier.js | 1 - .../reference/keywordInJsxIdentifier.symbols | 11 +- .../reference/keywordInJsxIdentifier.types | 1 - tests/baselines/reference/lambdaASIEmit.js | 1 - .../baselines/reference/lambdaASIEmit.symbols | 3 +- tests/baselines/reference/lambdaASIEmit.types | 1 - .../letAndVarRedeclaration.errors.txt | 44 +- .../reference/letAndVarRedeclaration.js | 2 - .../reference/letAsIdentifier.errors.txt | 5 +- tests/baselines/reference/letAsIdentifier.js | 1 - tests/baselines/reference/letAsIdentifier2.js | 1 - .../reference/letAsIdentifier2.symbols | 1 - .../reference/letAsIdentifier2.types | 1 - .../letConstInCaseClauses.errors.txt | 9 +- .../reference/letConstInCaseClauses.js | 1 - .../reference/letDeclarations-access.js | 1 - .../reference/letDeclarations-access.symbols | 59 +- .../reference/letDeclarations-access.types | 1 - .../reference/letDeclarations-es5.js | 1 - .../reference/letDeclarations-es5.symbols | 31 +- .../reference/letDeclarations-es5.types | 1 - ...letDeclarations-invalidContexts.errors.txt | 18 +- .../letDeclarations-invalidContexts.js | 2 - ...tDeclarations-scopes-duplicates.errors.txt | 31 +- .../letDeclarations-scopes-duplicates.js | 1 - ...Declarations-scopes-duplicates2.errors.txt | 3 +- .../letDeclarations-scopes-duplicates2.js | 1 - ...Declarations-scopes-duplicates3.errors.txt | 3 +- .../letDeclarations-scopes-duplicates3.js | 1 - ...Declarations-scopes-duplicates4.errors.txt | 3 +- .../letDeclarations-scopes-duplicates4.js | 1 - ...Declarations-scopes-duplicates5.errors.txt | 3 +- .../letDeclarations-scopes-duplicates5.js | 1 - ...Declarations-scopes-duplicates6.errors.txt | 3 +- .../letDeclarations-scopes-duplicates6.js | 1 - ...Declarations-scopes-duplicates7.errors.txt | 3 +- .../letDeclarations-scopes-duplicates7.js | 1 - .../letDeclarations-scopes.errors.txt | 4 +- .../reference/letDeclarations-scopes.js | 2 - .../letDeclarations-scopes2.errors.txt | 9 +- .../reference/letDeclarations-scopes2.js | 1 - ...eclarations-useBeforeDefinition.errors.txt | 5 +- .../letDeclarations-useBeforeDefinition.js | 1 - ...clarations-useBeforeDefinition2.errors.txt | 3 +- .../letDeclarations-useBeforeDefinition2.js | 1 - .../letDeclarations-validContexts.errors.txt | 5 +- .../letDeclarations-validContexts.js | 3 - tests/baselines/reference/letDeclarations.js | 1 - .../reference/letDeclarations.symbols | 31 +- .../baselines/reference/letDeclarations.types | 1 - tests/baselines/reference/letDeclarations2.js | 1 - .../reference/letDeclarations2.symbols | 5 +- .../reference/letDeclarations2.types | 1 - .../letInConstDeclarations_ES5.errors.txt | 5 +- .../reference/letInConstDeclarations_ES5.js | 1 - .../letInConstDeclarations_ES6.errors.txt | 5 +- .../reference/letInConstDeclarations_ES6.js | 1 - ...LetConstDeclOfForOfAndForIn_ES5.errors.txt | 17 +- .../letInLetConstDeclOfForOfAndForIn_ES5.js | 1 - ...LetConstDeclOfForOfAndForIn_ES6.errors.txt | 17 +- .../letInLetConstDeclOfForOfAndForIn_ES6.js | 1 - .../letInLetDeclarations_ES5.errors.txt | 5 +- .../reference/letInLetDeclarations_ES5.js | 1 - .../letInLetDeclarations_ES6.errors.txt | 5 +- .../reference/letInLetDeclarations_ES6.js | 1 - .../reference/letInVarDeclOfForIn_ES5.js | 1 - .../reference/letInVarDeclOfForIn_ES5.symbols | 5 +- .../reference/letInVarDeclOfForIn_ES5.types | 1 - .../reference/letInVarDeclOfForIn_ES6.js | 1 - .../reference/letInVarDeclOfForIn_ES6.symbols | 5 +- .../reference/letInVarDeclOfForIn_ES6.types | 1 - .../reference/letInVarDeclOfForOf_ES5.js | 1 - .../reference/letInVarDeclOfForOf_ES5.symbols | 5 +- .../reference/letInVarDeclOfForOf_ES5.types | 1 - .../reference/letInVarDeclOfForOf_ES6.js | 1 - .../reference/letInVarDeclOfForOf_ES6.symbols | 5 +- .../reference/letInVarDeclOfForOf_ES6.types | 1 - .../reference/library-reference-1.js | 1 - .../reference/library-reference-1.symbols | 11 +- .../reference/library-reference-1.types | 1 - .../reference/library-reference-10.js | 1 - .../reference/library-reference-11.js | 1 - .../reference/library-reference-12.js | 1 - .../reference/library-reference-14.js | 1 - .../reference/library-reference-14.symbols | 11 +- .../reference/library-reference-14.types | 1 - .../reference/library-reference-15.errors.txt | 1 - .../reference/library-reference-15.js | 1 - .../reference/library-reference-2.js | 1 - .../reference/library-reference-3.js | 1 - .../reference/library-reference-3.symbols | 11 +- .../reference/library-reference-3.types | 1 - .../reference/library-reference-4.js | 1 - .../reference/library-reference-4.symbols | 3 +- .../reference/library-reference-4.types | 1 - .../reference/library-reference-5.errors.txt | 1 - .../reference/library-reference-5.js | 1 - .../reference/library-reference-6.js | 1 - .../reference/library-reference-6.symbols | 11 +- .../reference/library-reference-6.types | 1 - .../reference/library-reference-7.js | 1 - .../reference/library-reference-7.symbols | 11 +- .../reference/library-reference-7.types | 1 - .../reference/library-reference-8.js | 1 - .../reference/library-reference-8.symbols | 11 +- .../reference/library-reference-8.types | 1 - tests/baselines/reference/literalTypes1.js | 1 - .../baselines/reference/literalTypes1.symbols | 93 +- tests/baselines/reference/literalTypes1.types | 1 - tests/baselines/reference/literalTypes3.js | 1 - .../baselines/reference/literalTypes3.symbols | 97 +- tests/baselines/reference/literalTypes3.types | 1 - tests/baselines/reference/literals.errors.txt | 13 +- tests/baselines/reference/literals.js | 1 - .../literalsInComputedProperties1.errors.txt | 3 +- .../literalsInComputedProperties1.js | 1 - .../reference/localClassesInLoop_ES6.js | 1 - .../reference/localClassesInLoop_ES6.symbols | 21 +- .../reference/localClassesInLoop_ES6.types | 1 - .../reference/localRequireFunction.js | 1 - .../reference/localRequireFunction.symbols | 11 +- .../reference/localRequireFunction.types | 1 - tests/baselines/reference/localTypes1.js | 1 - tests/baselines/reference/localTypes1.symbols | 321 +- tests/baselines/reference/localTypes1.types | 1 - .../reference/localTypes4.errors.txt | 9 +- tests/baselines/reference/localTypes4.js | 1 - .../reference/logicalAndOperatorStrictMode.js | 1 - .../logicalAndOperatorStrictMode.symbols | 407 +- .../logicalAndOperatorStrictMode.types | 1 - tests/baselines/reference/malformedTags.js | 1 - .../baselines/reference/malformedTags.symbols | 3 +- tests/baselines/reference/malformedTags.types | 1 - .../baselines/reference/mapOnTupleTypes01.js | 1 - .../reference/mapOnTupleTypes01.symbols | 101 +- .../reference/mapOnTupleTypes01.types | 1 - .../baselines/reference/mapOnTupleTypes02.js | 1 - .../reference/mapOnTupleTypes02.symbols | 11 +- .../reference/mapOnTupleTypes02.types | 1 - .../reference/mappedTypeErrors.errors.txt | 53 +- tests/baselines/reference/mappedTypeErrors.js | 1 - .../reference/mappedTypeModifiers.js | 1 - .../reference/mappedTypeModifiers.symbols | 415 +- .../reference/mappedTypeModifiers.types | 1 - .../mappedTypeRelationships.errors.txt | 55 +- .../reference/mappedTypeRelationships.js | 1 - tests/baselines/reference/mappedTypes1.js | 1 - .../baselines/reference/mappedTypes1.symbols | 159 +- tests/baselines/reference/mappedTypes1.types | 1 - tests/baselines/reference/mappedTypes2.js | 1 - .../baselines/reference/mappedTypes2.symbols | 371 +- tests/baselines/reference/mappedTypes2.types | 1 - tests/baselines/reference/mappedTypes3.js | 1 - .../baselines/reference/mappedTypes3.symbols | 143 +- tests/baselines/reference/mappedTypes3.types | 1 - tests/baselines/reference/mappedTypes4.js | 1 - .../baselines/reference/mappedTypes4.symbols | 233 +- tests/baselines/reference/mappedTypes4.types | 1 - .../reference/mappedTypesAndObjects.js | 1 - .../reference/mappedTypesAndObjects.symbols | 113 +- .../reference/mappedTypesAndObjects.types | 1 - .../reference/mergeClassInterfaceAndModule.js | 1 - .../mergeClassInterfaceAndModule.symbols | 25 +- .../mergeClassInterfaceAndModule.types | 1 - .../reference/mergedClassInterface.js | 4 - .../reference/mergedClassInterface.symbols | 68 +- .../reference/mergedClassInterface.types | 4 - .../reference/mergedDeclarations6.js | 1 - .../reference/mergedDeclarations6.symbols | 13 +- .../reference/mergedDeclarations6.types | 1 - .../mergedInterfaceFromMultipleFiles1.js | 1 - .../mergedInterfaceFromMultipleFiles1.symbols | 19 +- .../mergedInterfaceFromMultipleFiles1.types | 1 - .../reference/metadataOfEventAlias.js | 1 - .../reference/metadataOfEventAlias.symbols | 3 +- .../reference/metadataOfEventAlias.types | 1 - .../reference/missingDecoratorType.errors.txt | 1 - .../reference/missingDecoratorType.js | 1 - .../missingFunctionImplementation.errors.txt | 33 +- .../missingFunctionImplementation.js | 1 - .../missingImportAfterModuleImport.js | 1 - .../missingImportAfterModuleImport.symbols | 9 +- .../missingImportAfterModuleImport.types | 1 - .../missingSemicolonInModuleSpecifier.js | 1 - .../missingSemicolonInModuleSpecifier.symbols | 3 +- .../missingSemicolonInModuleSpecifier.types | 1 - .../misspelledJsDocTypedefTags.symbols | 3 +- .../misspelledJsDocTypedefTags.types | 1 - .../reference/mixinAccessModifiers.errors.txt | 35 +- .../reference/mixinAccessModifiers.js | 1 - .../reference/mixinClassesAnnotated.js | 1 - .../reference/mixinClassesAnnotated.symbols | 189 +- .../reference/mixinClassesAnnotated.types | 1 - .../reference/mixinClassesMembers.js | 1 - .../reference/mixinClassesMembers.symbols | 297 +- .../reference/mixinClassesMembers.types | 1 - ...ifierOnClassDeclarationMemberInFunction.js | 1 - ...OnClassDeclarationMemberInFunction.symbols | 9 +- ...erOnClassDeclarationMemberInFunction.types | 1 - ...difierOnClassExpressionMemberInFunction.js | 1 - ...rOnClassExpressionMemberInFunction.symbols | 11 +- ...ierOnClassExpressionMemberInFunction.types | 1 - .../modularizeLibrary_Dom.iterable.js | 1 - .../modularizeLibrary_Dom.iterable.symbols | 5 +- .../modularizeLibrary_Dom.iterable.types | 1 - ...singES6ArrayWithOnlyES6ArrayLib.errors.txt | 3 +- ...rorFromUsingES6ArrayWithOnlyES6ArrayLib.js | 1 - ...mUsingES6FeaturesWithOnlyES5Lib.errors.txt | 25 +- ...ErrorFromUsingES6FeaturesWithOnlyES5Lib.js | 1 - ...bolWithOutES6WellknownSymbolLib.errors.txt | 5 +- ...knownSymbolWithOutES6WellknownSymbolLib.js | 1 - ...rizeLibrary_NoErrorDuplicateLibOptions1.js | 1 - ...ibrary_NoErrorDuplicateLibOptions1.symbols | 77 +- ...eLibrary_NoErrorDuplicateLibOptions1.types | 1 - ...rizeLibrary_NoErrorDuplicateLibOptions2.js | 1 - ...ibrary_NoErrorDuplicateLibOptions2.symbols | 77 +- ...eLibrary_NoErrorDuplicateLibOptions2.types | 1 - .../modularizeLibrary_TargetES5UsingES6Lib.js | 1 - ...larizeLibrary_TargetES5UsingES6Lib.symbols | 77 +- ...dularizeLibrary_TargetES5UsingES6Lib.types | 1 - .../modularizeLibrary_TargetES6UsingES6Lib.js | 1 - ...larizeLibrary_TargetES6UsingES6Lib.symbols | 45 +- ...dularizeLibrary_TargetES6UsingES6Lib.types | 1 - ...larizeLibrary_UsingES5LibAndES6ArrayLib.js | 1 - ...eLibrary_UsingES5LibAndES6ArrayLib.symbols | 7 +- ...izeLibrary_UsingES5LibAndES6ArrayLib.types | 1 - ...izeLibrary_UsingES5LibAndES6FeatureLibs.js | 1 - ...brary_UsingES5LibAndES6FeatureLibs.symbols | 17 +- ...Library_UsingES5LibAndES6FeatureLibs.types | 1 - ...gES5LibES6ArrayLibES6WellknownSymbolLib.js | 1 - ...ibES6ArrayLibES6WellknownSymbolLib.symbols | 11 +- ...5LibES6ArrayLibES6WellknownSymbolLib.types | 1 - ...gmentationCollidingNamesInAugmentation1.js | 1 - ...ationCollidingNamesInAugmentation1.symbols | 11 +- ...ntationCollidingNamesInAugmentation1.types | 1 - .../moduleAugmentationDeclarationEmit1.js | 1 - ...moduleAugmentationDeclarationEmit1.symbols | 45 +- .../moduleAugmentationDeclarationEmit1.types | 1 - .../moduleAugmentationDeclarationEmit2.js | 1 - ...moduleAugmentationDeclarationEmit2.symbols | 49 +- .../moduleAugmentationDeclarationEmit2.types | 1 - ...ugmentationDisallowedExtensions.errors.txt | 16 +- .../moduleAugmentationDisallowedExtensions.js | 2 - .../moduleAugmentationExtendAmbientModule1.js | 2 - ...leAugmentationExtendAmbientModule1.symbols | 60 +- ...duleAugmentationExtendAmbientModule1.types | 2 - .../moduleAugmentationExtendAmbientModule2.js | 2 - ...leAugmentationExtendAmbientModule2.symbols | 72 +- ...duleAugmentationExtendAmbientModule2.types | 2 - .../moduleAugmentationExtendFileModule1.js | 1 - ...oduleAugmentationExtendFileModule1.symbols | 45 +- .../moduleAugmentationExtendFileModule1.types | 1 - .../moduleAugmentationExtendFileModule2.js | 1 - ...oduleAugmentationExtendFileModule2.symbols | 49 +- .../moduleAugmentationExtendFileModule2.types | 1 - .../reference/moduleAugmentationGlobal1.js | 1 - .../moduleAugmentationGlobal1.symbols | 7 +- .../reference/moduleAugmentationGlobal1.types | 1 - .../reference/moduleAugmentationGlobal2.js | 2 - .../moduleAugmentationGlobal2.symbols | 22 +- .../reference/moduleAugmentationGlobal2.types | 2 - .../reference/moduleAugmentationGlobal3.js | 2 - .../moduleAugmentationGlobal3.symbols | 16 +- .../reference/moduleAugmentationGlobal3.types | 2 - .../reference/moduleAugmentationGlobal4.js | 2 - .../moduleAugmentationGlobal4.symbols | 10 +- .../reference/moduleAugmentationGlobal4.types | 2 - .../reference/moduleAugmentationGlobal5.js | 1 - .../moduleAugmentationGlobal5.symbols | 9 +- .../reference/moduleAugmentationGlobal5.types | 1 - .../moduleAugmentationImportsAndExports1.js | 1 - ...duleAugmentationImportsAndExports1.symbols | 1 - ...moduleAugmentationImportsAndExports1.types | 1 - ...eAugmentationImportsAndExports2.errors.txt | 1 - .../moduleAugmentationImportsAndExports2.js | 1 - ...eAugmentationImportsAndExports3.errors.txt | 1 - .../moduleAugmentationImportsAndExports3.js | 1 - .../moduleAugmentationImportsAndExports4.js | 1 - ...duleAugmentationImportsAndExports4.symbols | 1 - ...moduleAugmentationImportsAndExports4.types | 1 - ...eAugmentationImportsAndExports5.errors.txt | 1 - .../moduleAugmentationImportsAndExports5.js | 1 - .../moduleAugmentationImportsAndExports6.js | 1 - ...duleAugmentationImportsAndExports6.symbols | 1 - ...moduleAugmentationImportsAndExports6.types | 1 - .../moduleAugmentationInAmbientModule1.js | 2 - ...moduleAugmentationInAmbientModule1.symbols | 24 +- .../moduleAugmentationInAmbientModule1.types | 2 - .../moduleAugmentationInAmbientModule2.js | 1 - ...moduleAugmentationInAmbientModule2.symbols | 23 +- .../moduleAugmentationInAmbientModule2.types | 1 - .../moduleAugmentationInAmbientModule3.js | 1 - ...moduleAugmentationInAmbientModule3.symbols | 41 +- .../moduleAugmentationInAmbientModule3.types | 1 - .../moduleAugmentationInAmbientModule4.js | 1 - ...moduleAugmentationInAmbientModule4.symbols | 25 +- .../moduleAugmentationInAmbientModule4.types | 1 - .../moduleAugmentationInAmbientModule5.js | 1 - ...moduleAugmentationInAmbientModule5.symbols | 25 +- .../moduleAugmentationInAmbientModule5.types | 1 - .../reference/moduleAugmentationNoNewNames.js | 1 - .../moduleAugmentationNoNewNames.symbols | 59 +- .../moduleAugmentationNoNewNames.types | 1 - .../moduleAugmentationsBundledOutput1.js | 1 - .../moduleAugmentationsBundledOutput1.symbols | 1 - .../moduleAugmentationsBundledOutput1.types | 1 - .../reference/moduleAugmentationsImports1.js | 1 - .../moduleAugmentationsImports1.symbols | 1 - .../moduleAugmentationsImports1.types | 1 - .../reference/moduleAugmentationsImports2.js | 1 - .../moduleAugmentationsImports2.symbols | 1 - .../moduleAugmentationsImports2.types | 1 - .../reference/moduleAugmentationsImports3.js | 1 - .../moduleAugmentationsImports3.symbols | 1 - .../moduleAugmentationsImports3.types | 1 - .../reference/moduleAugmentationsImports4.js | 1 - .../moduleAugmentationsImports4.symbols | 1 - .../moduleAugmentationsImports4.types | 1 - .../reference/moduleMergeConstructor.js | 1 - .../reference/moduleMergeConstructor.symbols | 13 +- .../reference/moduleMergeConstructor.types | 1 - .../reference/moduleOuterQualification.js | 1 - .../moduleOuterQualification.symbols | 11 +- .../reference/moduleOuterQualification.types | 1 - .../reference/moduleResolutionNoResolve.js | 1 - .../moduleResolutionNoResolve.symbols | 1 - .../reference/moduleResolutionNoResolve.types | 1 - .../moduleResolutionWithExtensions.js | 1 - .../moduleResolutionWithExtensions.symbols | 3 +- .../moduleResolutionWithExtensions.types | 3 +- ...tionWithExtensions_notSupported.errors.txt | 1 - ...leResolutionWithExtensions_notSupported.js | 1 - ...moduleResolutionWithExtensions_preferTs.js | 1 - .../reference/moduleSymbolMerging.js | 1 - .../reference/moduleSymbolMerging.symbols | 5 +- .../reference/moduleSymbolMerging.types | 1 - .../reference/moduleVisibilityTest1.js | 2 - .../reference/moduleVisibilityTest1.symbols | 152 +- .../reference/moduleVisibilityTest1.types | 2 - .../moduleVisibilityTest2.errors.txt | 14 +- .../reference/moduleVisibilityTest2.js | 2 - tests/baselines/reference/moduledecl.js | 1 - tests/baselines/reference/moduledecl.symbols | 415 +- tests/baselines/reference/moduledecl.types | 1 - .../multipleDefaultExports01.errors.txt | 7 +- .../reference/multipleDefaultExports01.js | 1 - .../multipleDefaultExports02.errors.txt | 9 +- .../reference/multipleDefaultExports02.js | 1 - .../multipleDefaultExports03.errors.txt | 5 +- .../reference/multipleDefaultExports03.js | 1 - .../multipleDefaultExports04.errors.txt | 9 +- .../reference/multipleDefaultExports04.js | 1 - .../reference/multipleExports.errors.txt | 5 +- tests/baselines/reference/multipleExports.js | 1 - .../reference/namespacesDeclaration1.js | 1 - .../reference/namespacesDeclaration1.symbols | 7 +- .../reference/namespacesDeclaration1.types | 1 - .../namespacesDeclaration2.errors.txt | 7 +- .../reference/namespacesDeclaration2.js | 1 - .../reference/narrowedConstInMethod.js | 1 - .../reference/narrowedConstInMethod.symbols | 19 +- .../reference/narrowedConstInMethod.types | 1 - .../narrowingByDiscriminantInLoop.js | 1 - .../narrowingByDiscriminantInLoop.symbols | 241 +- .../narrowingByDiscriminantInLoop.types | 1 - .../narrowingConstrainedTypeParameter.js | 1 - .../narrowingConstrainedTypeParameter.symbols | 33 +- .../narrowingConstrainedTypeParameter.types | 1 - tests/baselines/reference/neverType.js | 2 - tests/baselines/reference/neverType.symbols | 100 +- tests/baselines/reference/neverType.types | 2 - .../reference/neverTypeErrors2.errors.txt | 19 +- tests/baselines/reference/neverTypeErrors2.js | 1 - .../newExpressionWithCast.errors.txt | 9 +- .../reference/newExpressionWithCast.js | 1 - .../newNamesInGlobalAugmentations1.errors.txt | 4 +- .../newNamesInGlobalAugmentations1.js | 2 - .../reference/newOperatorConformance.js | 1 - .../reference/newOperatorConformance.symbols | 101 +- .../reference/newOperatorConformance.types | 1 - .../newOperatorErrorCases.errors.txt | 9 +- .../reference/newOperatorErrorCases.js | 1 - .../reference/newWithSpread.errors.txt | 29 +- tests/baselines/reference/newWithSpread.js | 1 - tests/baselines/reference/newWithSpreadES5.js | 1 - .../reference/newWithSpreadES5.symbols | 261 +- .../reference/newWithSpreadES5.types | 1 - tests/baselines/reference/newWithSpreadES6.js | 1 - .../reference/newWithSpreadES6.symbols | 261 +- .../reference/newWithSpreadES6.types | 1 - .../reference/noBundledEmitFromNodeModules.js | 1 - .../noBundledEmitFromNodeModules.symbols | 1 - .../noBundledEmitFromNodeModules.types | 1 - tests/baselines/reference/noCatchBlock.js | 1 - tests/baselines/reference/noCatchBlock.js.map | 2 +- .../reference/noCatchBlock.sourcemap.txt | 29 +- .../baselines/reference/noCatchBlock.symbols | 3 +- tests/baselines/reference/noCatchBlock.types | 3 +- tests/baselines/reference/noEmitHelpers.js | 1 - .../baselines/reference/noEmitHelpers.symbols | 3 +- tests/baselines/reference/noEmitHelpers.types | 1 - tests/baselines/reference/noEmitHelpers2.js | 1 - .../reference/noEmitHelpers2.symbols | 13 +- .../baselines/reference/noEmitHelpers2.types | 1 - .../reference/noEmitOnError.errors.txt | 3 +- ...duleAugmentationInDeclarationFile1.symbols | 5 +- ...ModuleAugmentationInDeclarationFile1.types | 1 - ...eAugmentationInDeclarationFile2.errors.txt | 3 +- ...ortModuleAugmentationInDeclarationFile2.js | 1 - ...eAugmentationInDeclarationFile3.errors.txt | 1 - ...ortModuleAugmentationInDeclarationFile3.js | 1 - .../reference/noImplicitAnyForIn.errors.txt | 9 +- .../baselines/reference/noImplicitAnyForIn.js | 1 - ...ImplicitAnyFunctionExpressionAssignment.js | 1 - ...citAnyFunctionExpressionAssignment.symbols | 23 +- ...licitAnyFunctionExpressionAssignment.types | 1 - .../noImplicitAnyFunctions.errors.txt | 11 +- .../reference/noImplicitAnyFunctions.js | 1 - .../noImplicitAnyInBareInterface.errors.txt | 5 +- .../reference/noImplicitAnyInBareInterface.js | 1 - .../noImplicitAnyInCastExpression.errors.txt | 3 +- .../noImplicitAnyInCastExpression.js | 1 - ...tAnyInContextuallyTypesFunctionParamter.js | 1 - ...nContextuallyTypesFunctionParamter.symbols | 9 +- ...yInContextuallyTypesFunctionParamter.types | 1 - .../noImplicitAnyIndexing.errors.txt | 9 +- .../reference/noImplicitAnyIndexing.js | 1 - .../noImplicitAnyIndexingSuppressed.js | 1 - .../noImplicitAnyIndexingSuppressed.symbols | 71 +- .../noImplicitAnyIndexingSuppressed.types | 1 - ...noImplicitAnyMissingGetAccessor.errors.txt | 9 +- .../noImplicitAnyMissingGetAccessor.js | 1 - ...noImplicitAnyMissingSetAccessor.errors.txt | 3 +- .../noImplicitAnyMissingSetAccessor.js | 1 - .../reference/noImplicitAnyModule.errors.txt | 9 +- .../reference/noImplicitAnyModule.js | 1 - ...icitAnyParametersInAmbientClass.errors.txt | 63 +- .../noImplicitAnyParametersInAmbientClass.js | 1 - ...AnyParametersInAmbientFunctions.errors.txt | 45 +- ...ImplicitAnyParametersInAmbientFunctions.js | 1 - ...citAnyParametersInAmbientModule.errors.txt | 45 +- .../noImplicitAnyParametersInAmbientModule.js | 1 - ...citAnyParametersInBareFunctions.errors.txt | 45 +- .../noImplicitAnyParametersInBareFunctions.js | 1 - .../noImplicitAnyParametersInClass.errors.txt | 89 +- .../noImplicitAnyParametersInClass.js | 1 - ...mplicitAnyParametersInInterface.errors.txt | 53 +- .../noImplicitAnyParametersInInterface.js | 1 - ...noImplicitAnyParametersInModule.errors.txt | 45 +- .../noImplicitAnyParametersInModule.js | 1 - ...AnyReferencingDeclaredInterface.errors.txt | 3 +- ...ImplicitAnyReferencingDeclaredInterface.js | 1 - ...mplicitAnyStringIndexerOnObject.errors.txt | 3 +- .../noImplicitAnyStringIndexerOnObject.js | 1 - .../reference/noImplicitReturnsInAsync1.js | 1 - .../noImplicitReturnsInAsync1.symbols | 7 +- .../reference/noImplicitReturnsInAsync1.types | 1 - .../noImplicitReturnsInAsync2.errors.txt | 5 +- .../reference/noImplicitReturnsInAsync2.js | 1 - .../noImplicitThisFunctions.errors.txt | 5 +- .../reference/noImplicitThisFunctions.js | 1 - .../reference/noImplicitUseStrict_amd.js | 1 - .../reference/noImplicitUseStrict_amd.symbols | 3 +- .../reference/noImplicitUseStrict_amd.types | 1 - .../reference/noImplicitUseStrict_commonjs.js | 1 - .../noImplicitUseStrict_commonjs.symbols | 3 +- .../noImplicitUseStrict_commonjs.types | 1 - .../reference/noImplicitUseStrict_es6.js | 1 - .../reference/noImplicitUseStrict_es6.symbols | 3 +- .../reference/noImplicitUseStrict_es6.types | 1 - .../reference/noImplicitUseStrict_system.js | 1 - .../noImplicitUseStrict_system.symbols | 3 +- .../noImplicitUseStrict_system.types | 1 - .../reference/noImplicitUseStrict_umd.js | 1 - .../reference/noImplicitUseStrict_umd.symbols | 3 +- .../reference/noImplicitUseStrict_umd.types | 1 - ...eforeDefinedErrorInAmbientContext1.symbols | 7 +- ...dBeforeDefinedErrorInAmbientContext1.types | 1 - tests/baselines/reference/nodeResolution1.js | 1 - .../reference/nodeResolution1.symbols | 3 +- .../baselines/reference/nodeResolution1.types | 1 - tests/baselines/reference/nodeResolution2.js | 1 - .../reference/nodeResolution2.symbols | 3 +- .../baselines/reference/nodeResolution2.types | 1 - tests/baselines/reference/nodeResolution3.js | 1 - .../reference/nodeResolution3.symbols | 3 +- .../baselines/reference/nodeResolution3.types | 1 - tests/baselines/reference/nodeResolution4.js | 1 - .../reference/nodeResolution4.symbols | 3 +- .../baselines/reference/nodeResolution4.types | 1 - tests/baselines/reference/nodeResolution5.js | 1 - .../reference/nodeResolution5.symbols | 3 +- .../baselines/reference/nodeResolution5.types | 1 - tests/baselines/reference/nodeResolution6.js | 1 - .../reference/nodeResolution6.symbols | 3 +- .../baselines/reference/nodeResolution6.types | 1 - tests/baselines/reference/nodeResolution7.js | 1 - .../reference/nodeResolution7.symbols | 3 +- .../baselines/reference/nodeResolution7.types | 1 - tests/baselines/reference/nodeResolution8.js | 1 - .../reference/nodeResolution8.symbols | 3 +- .../baselines/reference/nodeResolution8.types | 1 - .../nonPrimitiveStrictNull.errors.txt | 37 +- .../reference/nonPrimitiveStrictNull.js | 1 - .../nounusedTypeParameterConstraint.js | 1 - .../nounusedTypeParameterConstraint.symbols | 1 - .../nounusedTypeParameterConstraint.types | 1 - tests/baselines/reference/null.errors.txt | 3 +- tests/baselines/reference/null.js | 1 - .../reference/numericLiteralTypes2.js | 1 - .../reference/numericLiteralTypes2.symbols | 401 +- .../reference/numericLiteralTypes2.types | 1 - ...dingPatternKeywordIdentifiers01.errors.txt | 3 +- ...bjectBindingPatternKeywordIdentifiers01.js | 1 - ...dingPatternKeywordIdentifiers02.errors.txt | 5 +- ...bjectBindingPatternKeywordIdentifiers02.js | 1 - ...dingPatternKeywordIdentifiers03.errors.txt | 3 +- ...bjectBindingPatternKeywordIdentifiers03.js | 1 - ...dingPatternKeywordIdentifiers04.errors.txt | 5 +- ...bjectBindingPatternKeywordIdentifiers04.js | 1 - ...bjectBindingPatternKeywordIdentifiers05.js | 1 - ...BindingPatternKeywordIdentifiers05.symbols | 5 +- ...ctBindingPatternKeywordIdentifiers05.types | 1 - ...bjectBindingPatternKeywordIdentifiers06.js | 1 - ...BindingPatternKeywordIdentifiers06.symbols | 7 +- ...ctBindingPatternKeywordIdentifiers06.types | 1 - .../reference/objectCreate-errors.errors.txt | 17 +- .../reference/objectCreate-errors.js | 1 - tests/baselines/reference/objectCreate.js | 1 - .../baselines/reference/objectCreate.symbols | 39 +- tests/baselines/reference/objectCreate.types | 1 - tests/baselines/reference/objectCreate2.js | 1 - .../baselines/reference/objectCreate2.symbols | 39 +- tests/baselines/reference/objectCreate2.types | 1 - .../reference/objectLiteralErrors.errors.txt | 121 +- .../reference/objectLiteralErrors.js | 1 - .../objectLiteralErrorsES3.errors.txt | 5 +- .../reference/objectLiteralErrorsES3.js | 1 - ...LiteralShorthandPropertiesWithModuleES6.js | 1 - ...alShorthandPropertiesWithModuleES6.symbols | 19 +- ...eralShorthandPropertiesWithModuleES6.types | 1 - .../reference/objectSpreadStrictNull.js | 1 - .../reference/objectSpreadStrictNull.symbols | 95 +- .../reference/objectSpreadStrictNull.types | 1 - ...bjectTypeWithStringNamedNumericProperty.js | 1 - ...TypeWithStringNamedNumericProperty.symbols | 389 +- ...ctTypeWithStringNamedNumericProperty.types | 1 - .../optionalBindingParameters1.errors.txt | 5 +- .../reference/optionalBindingParameters1.js | 1 - .../optionalBindingParameters2.errors.txt | 5 +- .../reference/optionalBindingParameters2.js | 1 - ...alBindingParametersInOverloads1.errors.txt | 3 +- .../optionalBindingParametersInOverloads1.js | 1 - ...alBindingParametersInOverloads2.errors.txt | 3 +- .../optionalBindingParametersInOverloads2.js | 1 - tests/baselines/reference/optionalMethods.js | 1 - .../reference/optionalMethods.symbols | 217 +- .../baselines/reference/optionalMethods.types | 1 - .../optionalParameterProperty.errors.txt | 3 +- .../reference/optionalParameterProperty.js | 1 - ...ParamterAndVariableDeclaration2.errors.txt | 3 +- ...optionalParamterAndVariableDeclaration2.js | 1 - .../reference/optionalProperties01.js | 1 - .../reference/optionalProperties01.symbols | 17 +- .../reference/optionalProperties01.types | 1 - .../reference/optionalProperties02.js | 1 - .../reference/optionalProperties02.symbols | 7 +- .../reference/optionalProperties02.types | 1 - .../optionsInlineSourceMapMapRoot.errors.txt | 1 - .../optionsInlineSourceMapMapRoot.js | 3 +- ...ptionsInlineSourceMapMapRoot.sourcemap.txt | 19 +- .../optionsInlineSourceMapSourceRoot.js | 3 +- ...onsInlineSourceMapSourceRoot.sourcemap.txt | 19 +- .../optionsInlineSourceMapSourceRoot.symbols | 3 +- .../optionsInlineSourceMapSourceRoot.types | 1 - ...optionsInlineSourceMapSourcemap.errors.txt | 1 - .../optionsInlineSourceMapSourcemap.js | 3 +- ...ionsInlineSourceMapSourcemap.sourcemap.txt | 19 +- .../optionsOutAndNoModuleGen.errors.txt | 3 +- .../optionsSourcemapInlineSources.js | 1 - .../optionsSourcemapInlineSources.js.map | 2 +- ...ptionsSourcemapInlineSources.sourcemap.txt | 17 +- .../optionsSourcemapInlineSources.symbols | 3 +- .../optionsSourcemapInlineSources.types | 1 - .../optionsSourcemapInlineSourcesMapRoot.js | 1 - ...ptionsSourcemapInlineSourcesMapRoot.js.map | 2 +- ...ourcemapInlineSourcesMapRoot.sourcemap.txt | 17 +- ...tionsSourcemapInlineSourcesMapRoot.symbols | 3 +- ...optionsSourcemapInlineSourcesMapRoot.types | 1 - ...optionsSourcemapInlineSourcesSourceRoot.js | 1 - ...onsSourcemapInlineSourcesSourceRoot.js.map | 2 +- ...cemapInlineSourcesSourceRoot.sourcemap.txt | 17 +- ...nsSourcemapInlineSourcesSourceRoot.symbols | 3 +- ...ionsSourcemapInlineSourcesSourceRoot.types | 1 - .../baselines/reference/out-flag2.errors.txt | 1 - tests/baselines/reference/out-flag2.js | 1 - tests/baselines/reference/out-flag2.js.map | 2 +- .../reference/out-flag2.sourcemap.txt | 23 +- .../baselines/reference/out-flag3.errors.txt | 1 - tests/baselines/reference/out-flag3.js | 1 - tests/baselines/reference/out-flag3.js.map | 2 +- .../reference/out-flag3.sourcemap.txt | 27 +- .../baselines/reference/outModuleConcatAmd.js | 1 - .../reference/outModuleConcatAmd.js.map | 2 +- .../outModuleConcatAmd.sourcemap.txt | 27 +- .../reference/outModuleConcatAmd.symbols | 1 - .../reference/outModuleConcatAmd.types | 1 - .../outModuleConcatCommonjs.errors.txt | 1 - .../reference/outModuleConcatES6.errors.txt | 1 - .../reference/outModuleConcatSystem.js | 1 - .../reference/outModuleConcatSystem.js.map | 2 +- .../outModuleConcatSystem.sourcemap.txt | 27 +- .../reference/outModuleConcatSystem.symbols | 1 - .../reference/outModuleConcatSystem.types | 1 - .../reference/outModuleConcatUmd.errors.txt | 1 - ...duleConcatUnspecifiedModuleKind.errors.txt | 3 +- .../outModuleConcatUnspecifiedModuleKind.js | 1 - .../reference/outModuleTripleSlashRefs.js | 1 - .../reference/outModuleTripleSlashRefs.js.map | 2 +- .../outModuleTripleSlashRefs.sourcemap.txt | 31 +- .../outModuleTripleSlashRefs.symbols | 3 +- .../reference/outModuleTripleSlashRefs.types | 1 - .../overloadAssignmentCompat.errors.txt | 3 +- .../reference/overloadAssignmentCompat.js | 1 - .../overloadOnConstAsTypeAnnotation.js | 1 - .../overloadOnConstAsTypeAnnotation.symbols | 7 +- .../overloadOnConstAsTypeAnnotation.types | 1 - .../overloadResolutionTest1.errors.txt | 7 +- .../reference/overloadResolutionTest1.js | 1 - tests/baselines/reference/packageJsonMain.js | 1 - .../packageJsonMain_isNonRecursive.errors.txt | 1 - .../packageJsonMain_isNonRecursive.js | 1 - .../paramterDestrcuturingDeclaration.js | 1 - .../paramterDestrcuturingDeclaration.symbols | 5 +- .../paramterDestrcuturingDeclaration.types | 1 - .../parenthesizedContexualTyping1.errors.txt | 9 +- .../parenthesizedContexualTyping1.js | 1 - .../parenthesizedContexualTyping3.js | 1 - .../parenthesizedContexualTyping3.symbols | 133 +- .../parenthesizedContexualTyping3.types | 1 - .../baselines/reference/parseTypes.errors.txt | 7 +- tests/baselines/reference/parseTypes.js | 1 - .../reference/parser10.1.1-8gs.errors.txt | 5 +- tests/baselines/reference/parser10.1.1-8gs.js | 1 - tests/baselines/reference/parser768531.js | 1 - .../baselines/reference/parser768531.symbols | 3 +- tests/baselines/reference/parser768531.types | 1 - .../reference/parserClass2.errors.txt | 8 +- tests/baselines/reference/parserClass2.js | 2 - tests/baselines/reference/parserEnum1.js | 2 - tests/baselines/reference/parserEnum1.symbols | 10 +- tests/baselines/reference/parserEnum1.types | 2 - tests/baselines/reference/parserEnum2.js | 2 - tests/baselines/reference/parserEnum2.symbols | 10 +- tests/baselines/reference/parserEnum2.types | 2 - tests/baselines/reference/parserEnum3.js | 2 - tests/baselines/reference/parserEnum3.symbols | 2 - tests/baselines/reference/parserEnum3.types | 2 - .../reference/parserEnum4.errors.txt | 4 +- tests/baselines/reference/parserEnum4.js | 2 - ...RecoveryArrayLiteralExpression3.errors.txt | 9 +- ...serErrorRecoveryArrayLiteralExpression3.js | 1 - .../parserVariableDeclaration1.errors.txt | 9 +- .../reference/parserVariableDeclaration1.js | 1 - .../reference/parser_breakTarget3.js | 1 - .../reference/parser_breakTarget3.symbols | 3 +- .../reference/parser_breakTarget3.types | 1 - .../reference/parser_breakTarget4.js | 1 - .../reference/parser_breakTarget4.symbols | 3 +- .../reference/parser_breakTarget4.types | 1 - .../reference/parser_continueTarget3.js | 1 - .../reference/parser_continueTarget3.symbols | 3 +- .../reference/parser_continueTarget3.types | 1 - .../reference/parser_continueTarget4.js | 1 - .../reference/parser_continueTarget4.symbols | 3 +- .../reference/parser_continueTarget4.types | 1 - .../reference/parser_duplicateLabel3.js | 1 - .../reference/parser_duplicateLabel3.symbols | 3 +- .../reference/parser_duplicateLabel3.types | 1 - .../reference/parser_duplicateLabel4.js | 1 - .../reference/parser_duplicateLabel4.symbols | 3 +- .../reference/parser_duplicateLabel4.types | 1 - ...llyAnnotatedFunctionWitoutTypeParameter.js | 1 - ...notatedFunctionWitoutTypeParameter.symbols | 15 +- ...AnnotatedFunctionWitoutTypeParameter.types | 1 - ...thMappingBasedModuleResolution3_classic.js | 1 - ...pingBasedModuleResolution3_classic.symbols | 11 +- ...appingBasedModuleResolution3_classic.types | 1 - .../pathMappingBasedModuleResolution3_node.js | 1 - ...MappingBasedModuleResolution3_node.symbols | 11 +- ...thMappingBasedModuleResolution3_node.types | 1 - ...pingBasedModuleResolution_withExtension.js | 1 - ...asedModuleResolution_withExtension.symbols | 1 - ...gBasedModuleResolution_withExtension.types | 1 - ...tion_withExtension_failedLookup.errors.txt | 3 +- ...leResolution_withExtension_failedLookup.js | 1 - ...prefixUnaryOperatorsOnExportedVariables.js | 1 - ...xUnaryOperatorsOnExportedVariables.symbols | 19 +- ...fixUnaryOperatorsOnExportedVariables.types | 1 - .../privacyAccessorDeclFile.errors.txt | 49 +- .../reference/privacyAccessorDeclFile.js | 1 - ...ivacyCannotNameAccessorDeclFile.errors.txt | 1 - .../privacyCannotNameAccessorDeclFile.js | 1 - ...rivacyCannotNameVarTypeDeclFile.errors.txt | 2 - .../privacyCannotNameVarTypeDeclFile.js | 2 - ...ivacyClassExtendsClauseDeclFile.errors.txt | 13 +- .../privacyClassExtendsClauseDeclFile.js | 1 - ...cyClassImplementsClauseDeclFile.errors.txt | 11 +- .../privacyClassImplementsClauseDeclFile.js | 1 - ...CannotNameParameterTypeDeclFile.errors.txt | 2 - ...FunctionCannotNameParameterTypeDeclFile.js | 2 - ...ionCannotNameReturnTypeDeclFile.errors.txt | 2 - ...acyFunctionCannotNameReturnTypeDeclFile.js | 2 - ...rivacyFunctionParameterDeclFile.errors.txt | 81 +- .../privacyFunctionParameterDeclFile.js | 1 - ...ivacyFunctionReturnTypeDeclFile.errors.txt | 89 +- .../privacyFunctionReturnTypeDeclFile.js | 1 - ...yInterfaceExtendsClauseDeclFile.errors.txt | 11 +- .../privacyInterfaceExtendsClauseDeclFile.js | 1 - ...ternalModuleImportWithoutExport.errors.txt | 1 - ...mbientExternalModuleImportWithoutExport.js | 1 - ...nalReferenceImportWithoutExport.errors.txt | 11 +- ...velInternalReferenceImportWithoutExport.js | 1 - .../reference/privacyVarDeclFile.errors.txt | 41 +- .../baselines/reference/privacyVarDeclFile.js | 1 - tests/baselines/reference/promiseTest.js | 1 - tests/baselines/reference/promiseTest.symbols | 57 +- tests/baselines/reference/promiseTest.types | 1 - tests/baselines/reference/properties.js | 1 - tests/baselines/reference/properties.js.map | 2 +- .../reference/properties.sourcemap.txt | 61 +- tests/baselines/reference/properties.symbols | 7 +- tests/baselines/reference/properties.types | 1 - .../reference/propertyAssignment.errors.txt | 10 +- .../baselines/reference/propertyAssignment.js | 2 - ...yAccessibleWithinNestedSubclass.errors.txt | 3 +- ...sPropertyAccessibleWithinNestedSubclass.js | 1 - .../reference/protoAssignment.errors.txt | 3 +- tests/baselines/reference/protoAssignment.js | 1 - .../reference/reExportDefaultExport.js | 1 - .../reference/reExportDefaultExport.symbols | 3 +- .../reference/reExportDefaultExport.types | 1 - .../reExportGlobalDeclaration1.errors.txt | 1 - .../reference/reExportGlobalDeclaration1.js | 1 - .../reExportGlobalDeclaration2.errors.txt | 1 - .../reference/reExportGlobalDeclaration2.js | 1 - .../reExportGlobalDeclaration3.errors.txt | 1 - .../reference/reExportGlobalDeclaration3.js | 1 - .../reExportGlobalDeclaration4.errors.txt | 1 - .../reference/reExportGlobalDeclaration4.js | 1 - .../reference/reExportUndefined1.errors.txt | 3 +- .../baselines/reference/reExportUndefined1.js | 1 - .../baselines/reference/reExportUndefined2.js | 1 - .../reference/reExportUndefined2.symbols | 5 +- .../reference/reExportUndefined2.types | 1 - .../reference/reachabilityChecks1.errors.txt | 15 +- .../reference/reachabilityChecks1.js | 1 - .../reference/reachabilityChecks2.errors.txt | 3 +- .../reference/reachabilityChecks2.js | 1 - .../reference/reachabilityChecks3.errors.txt | 7 +- .../reference/reachabilityChecks3.js | 1 - .../reference/reachabilityChecks4.errors.txt | 3 +- .../reference/reachabilityChecks4.js | 1 - .../reference/reachabilityChecks5.errors.txt | 23 +- .../reference/reachabilityChecks5.js | 1 - .../reference/reachabilityChecks6.errors.txt | 21 +- .../reference/reachabilityChecks6.js | 1 - .../reference/reachabilityChecks7.errors.txt | 5 +- .../reference/reachabilityChecks7.js | 1 - .../baselines/reference/reactImportDropped.js | 1 - .../reference/reactImportDropped.symbols | 31 +- .../reference/reactImportDropped.types | 1 - .../reactNamespaceImportPresevation.js | 1 - .../reactNamespaceImportPresevation.symbols | 5 +- .../reactNamespaceImportPresevation.types | 1 - .../reactNamespaceInvalidInput.errors.txt | 3 +- .../reference/reactNamespaceInvalidInput.js | 1 - .../reference/reactNamespaceJSXEmit.js | 1 - .../reference/reactNamespaceJSXEmit.symbols | 27 +- .../reference/reactNamespaceJSXEmit.types | 1 - ...eactNamespaceMissingDeclaration.errors.txt | 3 +- .../reactNamespaceMissingDeclaration.js | 1 - .../reference/readonlyInDeclarationFile.js | 1 - .../readonlyInDeclarationFile.symbols | 95 +- .../reference/readonlyInDeclarationFile.types | 1 - ...readonlyInNonPropertyParameters.errors.txt | 7 +- .../readonlyInNonPropertyParameters.js | 1 - .../reference/readonlyMembers.errors.txt | 31 +- tests/baselines/reference/readonlyMembers.js | 1 - .../recurringTypeParamForContainerOfBase01.js | 1 - ...rringTypeParamForContainerOfBase01.symbols | 39 +- ...curringTypeParamForContainerOfBase01.types | 1 - .../recursiveIdenticalOverloadResolution.js | 1 - ...cursiveIdenticalOverloadResolution.symbols | 39 +- ...recursiveIdenticalOverloadResolution.types | 1 - .../reference/recursiveInheritance.errors.txt | 5 +- .../reference/recursiveInheritance.js | 1 - .../reference/recursiveMappedTypes.errors.txt | 7 +- .../reference/recursiveMappedTypes.js | 1 - tests/baselines/reference/recursiveMods.js | 1 - .../baselines/reference/recursiveMods.symbols | 33 +- tests/baselines/reference/recursiveMods.types | 1 - .../redeclareParameterInCatchBlock.errors.txt | 11 +- .../redeclareParameterInCatchBlock.js | 1 - ...elativeNamesInClassicResolution.errors.txt | 3 +- .../relativeNamesInClassicResolution.js | 1 - tests/baselines/reference/restUnion2.js | 1 - tests/baselines/reference/restUnion2.symbols | 49 +- tests/baselines/reference/restUnion2.types | 1 - tests/baselines/reference/returnStatement1.js | 1 - .../reference/returnStatement1.symbols | 7 +- .../reference/returnStatement1.types | 1 - .../reference/scannerClass2.errors.txt | 8 +- tests/baselines/reference/scannerClass2.js | 2 - .../reference/shebangBeforeReferences.js | 1 - .../reference/shebangBeforeReferences.symbols | 3 +- .../reference/shebangBeforeReferences.types | 1 - .../shorthand-property-es5-es6.errors.txt | 3 +- .../reference/shorthand-property-es5-es6.js | 1 - .../shorthand-property-es6-amd.errors.txt | 3 +- .../reference/shorthand-property-es6-amd.js | 1 - .../shorthand-property-es6-es6.errors.txt | 3 +- .../reference/shorthand-property-es6-es6.js | 1 - ...fExportedEntity01_targetES2015_CommonJS.js | 1 - ...rtedEntity01_targetES2015_CommonJS.symbols | 9 +- ...portedEntity01_targetES2015_CommonJS.types | 1 - ...ndOfExportedEntity02_targetES5_CommonJS.js | 1 - ...xportedEntity02_targetES5_CommonJS.symbols | 9 +- ...fExportedEntity02_targetES5_CommonJS.types | 1 - ...ndPropertyAssignmentInES6Module.errors.txt | 1 - .../shorthandPropertyAssignmentInES6Module.js | 1 - ...pertyAssignmentsInDestructuring.errors.txt | 30 +- ...thandPropertyAssignmentsInDestructuring.js | 2 - ...yAssignmentsInDestructuring_ES6.errors.txt | 30 +- ...dPropertyAssignmentsInDestructuring_ES6.js | 2 - .../reference/sourceMap-FileWithComments.js | 1 - .../sourceMap-FileWithComments.js.map | 2 +- .../sourceMap-FileWithComments.sourcemap.txt | 281 +- .../sourceMap-FileWithComments.symbols | 63 +- .../sourceMap-FileWithComments.types | 1 - ...-InterfacePrecedingVariableDeclaration1.js | 1 - ...erfacePrecedingVariableDeclaration1.js.map | 2 +- ...recedingVariableDeclaration1.sourcemap.txt | 15 +- ...rfacePrecedingVariableDeclaration1.symbols | 3 +- ...terfacePrecedingVariableDeclaration1.types | 1 - .../baselines/reference/sourceMap-NewLine1.js | 1 - .../reference/sourceMap-NewLine1.symbols | 1 - .../reference/sourceMap-NewLine1.types | 1 - .../sourceMap-StringLiteralWithNewLine.js | 1 - .../sourceMap-StringLiteralWithNewLine.js.map | 2 +- ...Map-StringLiteralWithNewLine.sourcemap.txt | 71 +- ...sourceMap-StringLiteralWithNewLine.symbols | 23 +- .../sourceMap-StringLiteralWithNewLine.types | 1 - ...ngVariableStatementArrayBindingPattern4.js | 1 - ...riableStatementArrayBindingPattern4.js.map | 2 +- ...tatementArrayBindingPattern4.sourcemap.txt | 11 +- ...iableStatementArrayBindingPattern4.symbols | 3 +- ...ariableStatementArrayBindingPattern4.types | 1 - ...ngVariableStatementArrayBindingPattern5.js | 1 - ...riableStatementArrayBindingPattern5.js.map | 2 +- ...tatementArrayBindingPattern5.sourcemap.txt | 27 +- ...iableStatementArrayBindingPattern5.symbols | 7 +- ...ariableStatementArrayBindingPattern5.types | 1 - ...ngVariableStatementArrayBindingPattern6.js | 1 - ...riableStatementArrayBindingPattern6.js.map | 2 +- ...tatementArrayBindingPattern6.sourcemap.txt | 15 +- ...iableStatementArrayBindingPattern6.symbols | 3 +- ...ariableStatementArrayBindingPattern6.types | 1 - ...ngVariableStatementArrayBindingPattern7.js | 1 - ...riableStatementArrayBindingPattern7.js.map | 2 +- ...tatementArrayBindingPattern7.sourcemap.txt | 23 +- ...iableStatementArrayBindingPattern7.symbols | 5 +- ...ariableStatementArrayBindingPattern7.types | 1 - ...gVariableStatementObjectBindingPattern1.js | 1 - ...iableStatementObjectBindingPattern1.js.map | 2 +- ...atementObjectBindingPattern1.sourcemap.txt | 11 +- ...ableStatementObjectBindingPattern1.symbols | 5 +- ...riableStatementObjectBindingPattern1.types | 1 - ...gVariableStatementObjectBindingPattern2.js | 1 - ...iableStatementObjectBindingPattern2.js.map | 2 +- ...atementObjectBindingPattern2.sourcemap.txt | 27 +- ...ableStatementObjectBindingPattern2.symbols | 13 +- ...riableStatementObjectBindingPattern2.types | 1 - ...gVariableStatementObjectBindingPattern3.js | 1 - ...iableStatementObjectBindingPattern3.js.map | 2 +- ...atementObjectBindingPattern3.sourcemap.txt | 15 +- ...ableStatementObjectBindingPattern3.symbols | 5 +- ...riableStatementObjectBindingPattern3.types | 1 - ...gVariableStatementObjectBindingPattern4.js | 1 - ...iableStatementObjectBindingPattern4.js.map | 2 +- ...atementObjectBindingPattern4.sourcemap.txt | 23 +- ...ableStatementObjectBindingPattern4.symbols | 9 +- ...riableStatementObjectBindingPattern4.types | 1 - .../reference/sourceMapValidationLabeled.js | 1 - .../sourceMapValidationLabeled.js.map | 2 +- .../sourceMapValidationLabeled.sourcemap.txt | 19 +- .../sourceMapValidationLabeled.symbols | 3 +- .../sourceMapValidationLabeled.types | 1 - ...specializationsShouldNotAffectEachOther.js | 1 - ...alizationsShouldNotAffectEachOther.symbols | 29 +- ...cializationsShouldNotAffectEachOther.types | 1 - ...ubtypeOfNonSpecializedSignature.errors.txt | 3 +- ...reIsNotSubtypeOfNonSpecializedSignature.js | 1 - tests/baselines/reference/spreadUnion2.js | 1 - .../baselines/reference/spreadUnion2.symbols | 77 +- tests/baselines/reference/spreadUnion2.types | 1 - ...pertyNameConflictsInAmbientContext.symbols | 59 +- ...ropertyNameConflictsInAmbientContext.types | 1 - .../reference/staticVisibility.errors.txt | 15 +- tests/baselines/reference/staticVisibility.js | 1 - ...vedWordInImportEqualDeclaration.errors.txt | 5 +- ...odeReservedWordInImportEqualDeclaration.js | 1 - .../reference/strictNullChecksNoWidening.js | 1 - .../strictNullChecksNoWidening.symbols | 39 +- .../strictNullChecksNoWidening.types | 1 - .../reference/strictNullLogicalAndOr.js | 1 - .../reference/strictNullLogicalAndOr.symbols | 25 +- .../reference/strictNullLogicalAndOr.types | 1 - tests/baselines/reference/stringIncludes.js | 1 - .../reference/stringIncludes.symbols | 7 +- .../baselines/reference/stringIncludes.types | 1 - .../reference/stringLiteralCheckedInIf01.js | 1 - .../stringLiteralCheckedInIf01.symbols | 19 +- .../stringLiteralCheckedInIf01.types | 1 - .../reference/stringLiteralCheckedInIf02.js | 1 - .../stringLiteralCheckedInIf02.symbols | 29 +- .../stringLiteralCheckedInIf02.types | 1 - .../stringLiteralMatchedInSwitch01.js | 1 - .../stringLiteralMatchedInSwitch01.symbols | 13 +- .../stringLiteralMatchedInSwitch01.types | 1 - .../reference/stringLiteralTypeAssertion01.js | 1 - .../stringLiteralTypeAssertion01.symbols | 67 +- .../stringLiteralTypeAssertion01.types | 1 - ...lTypesAndLogicalOrExpressions01.errors.txt | 3 +- ...ngLiteralTypesAndLogicalOrExpressions01.js | 1 - ...teralTypesAndParenthesizedExpressions01.js | 1 - ...TypesAndParenthesizedExpressions01.symbols | 9 +- ...alTypesAndParenthesizedExpressions01.types | 1 - .../stringLiteralTypesAndTuples01.js | 1 - .../stringLiteralTypesAndTuples01.symbols | 35 +- .../stringLiteralTypesAndTuples01.types | 1 - .../reference/stringLiteralTypesAsTags01.js | 1 - .../stringLiteralTypesAsTags01.symbols | 105 +- .../stringLiteralTypesAsTags01.types | 1 - .../reference/stringLiteralTypesAsTags02.js | 1 - .../stringLiteralTypesAsTags02.symbols | 99 +- .../stringLiteralTypesAsTags02.types | 1 - .../reference/stringLiteralTypesAsTags03.js | 1 - .../stringLiteralTypesAsTags03.symbols | 97 +- .../stringLiteralTypesAsTags03.types | 1 - ...LiteralTypesAsTypeParameterConstraint01.js | 1 - ...alTypesAsTypeParameterConstraint01.symbols | 63 +- ...eralTypesAsTypeParameterConstraint01.types | 1 - ...LiteralTypesAsTypeParameterConstraint02.js | 1 - ...alTypesAsTypeParameterConstraint02.symbols | 25 +- ...eralTypesAsTypeParameterConstraint02.types | 1 - .../stringLiteralTypesInUnionTypes01.js | 1 - .../stringLiteralTypesInUnionTypes01.symbols | 45 +- .../stringLiteralTypesInUnionTypes01.types | 1 - .../stringLiteralTypesInUnionTypes02.js | 1 - .../stringLiteralTypesInUnionTypes02.symbols | 45 +- .../stringLiteralTypesInUnionTypes02.types | 1 - .../stringLiteralTypesInUnionTypes03.js | 1 - .../stringLiteralTypesInUnionTypes03.symbols | 45 +- .../stringLiteralTypesInUnionTypes03.types | 1 - .../stringLiteralTypesInUnionTypes04.js | 1 - .../stringLiteralTypesInUnionTypes04.symbols | 53 +- .../stringLiteralTypesInUnionTypes04.types | 1 - ...alTypesInVariableDeclarations01.errors.txt | 3 +- ...ingLiteralTypesInVariableDeclarations01.js | 1 - ...ralTypesOverloadAssignability01.errors.txt | 5 +- ...ringLiteralTypesOverloadAssignability01.js | 1 - ...ralTypesOverloadAssignability02.errors.txt | 5 +- ...ringLiteralTypesOverloadAssignability02.js | 1 - ...ringLiteralTypesOverloadAssignability03.js | 1 - ...iteralTypesOverloadAssignability03.symbols | 33 +- ...gLiteralTypesOverloadAssignability03.types | 1 - ...ringLiteralTypesOverloadAssignability04.js | 1 - ...iteralTypesOverloadAssignability04.symbols | 33 +- ...gLiteralTypesOverloadAssignability04.types | 1 - ...ringLiteralTypesOverloadAssignability05.js | 1 - ...iteralTypesOverloadAssignability05.symbols | 37 +- ...gLiteralTypesOverloadAssignability05.types | 1 - .../stringLiteralTypesOverloads01.js | 1 - .../stringLiteralTypesOverloads01.symbols | 127 +- .../stringLiteralTypesOverloads01.types | 1 - .../stringLiteralTypesOverloads02.js | 1 - .../stringLiteralTypesOverloads02.symbols | 127 +- .../stringLiteralTypesOverloads02.types | 1 - .../stringLiteralTypesOverloads03.js | 1 - .../stringLiteralTypesOverloads03.symbols | 111 +- .../stringLiteralTypesOverloads03.types | 1 - .../stringLiteralTypesOverloads04.js | 1 - .../stringLiteralTypesOverloads04.symbols | 13 +- .../stringLiteralTypesOverloads04.types | 1 - .../stringLiteralTypesOverloads05.errors.txt | 3 +- .../stringLiteralTypesOverloads05.js | 1 - .../stringLiteralTypesTypePredicates01.js | 1 - ...stringLiteralTypesTypePredicates01.symbols | 51 +- .../stringLiteralTypesTypePredicates01.types | 1 - ...teralTypesWithTemplateStrings01.errors.txt | 7 +- ...stringLiteralTypesWithTemplateStrings01.js | 1 - ...teralTypesWithTemplateStrings02.errors.txt | 5 +- ...stringLiteralTypesWithTemplateStrings02.js | 1 - ...tringLiteralTypesWithVariousOperators01.js | 1 - ...LiteralTypesWithVariousOperators01.symbols | 125 +- ...ngLiteralTypesWithVariousOperators01.types | 1 - ...eralTypesWithVariousOperators02.errors.txt | 21 +- ...tringLiteralTypesWithVariousOperators02.js | 1 - tests/baselines/reference/stripInternal1.js | 1 - .../reference/stripInternal1.symbols | 5 +- .../baselines/reference/stripInternal1.types | 1 - .../structuralTypeInDeclareFileForModule.js | 1 - ...ructuralTypeInDeclareFileForModule.symbols | 5 +- ...structuralTypeInDeclareFileForModule.types | 1 - ...IncorrectNumberOfTypeArguments1.errors.txt | 3 +- ...eButWithIncorrectNumberOfTypeArguments1.js | 1 - ...ericTypeButWithNoTypeArguments1.errors.txt | 3 +- ...sFromGenericTypeButWithNoTypeArguments1.js | 1 - ...enericTypeButWithTypeArguments1.errors.txt | 3 +- ...ivesNonGenericTypeButWithTypeArguments1.js | 1 - ...CallFromClassThatHasNoBaseType1.errors.txt | 3 +- .../superCallFromClassThatHasNoBaseType1.js | 1 - .../superCallFromFunction1.errors.txt | 3 +- .../reference/superCallFromFunction1.js | 1 - .../superCallParameterContextualTyping1.js | 1 - ...uperCallParameterContextualTyping1.symbols | 19 +- .../superCallParameterContextualTyping1.types | 1 - ...rCallParameterContextualTyping2.errors.txt | 3 +- .../superCallParameterContextualTyping2.js | 1 - .../reference/superNewCall1.errors.txt | 7 +- tests/baselines/reference/superNewCall1.js | 1 - .../reference/superPropertyAccess.errors.txt | 15 +- .../reference/superPropertyAccess.js | 1 - .../superPropertyAccess_ES5.errors.txt | 5 +- .../reference/superPropertyAccess_ES5.js | 1 - .../reference/superPropertyAccess_ES6.js | 1 - .../reference/superPropertyAccess_ES6.symbols | 71 +- .../reference/superPropertyAccess_ES6.types | 1 - .../reference/superSymbolIndexedAccess2.js | 1 - .../superSymbolIndexedAccess2.symbols | 3 +- .../reference/superSymbolIndexedAccess2.types | 1 - .../switchBreakStatements.errors.txt | 23 +- .../reference/switchBreakStatements.js | 1 - ...itchCaseWithIntersectionTypes01.errors.txt | 5 +- .../switchCaseWithIntersectionTypes01.js | 1 - .../switchCaseWithUnionTypes01.errors.txt | 3 +- .../reference/switchCaseWithUnionTypes01.js | 1 - ...hStatementsWithMultipleDefaults.errors.txt | 7 +- .../switchStatementsWithMultipleDefaults.js | 1 - .../reference/systemExportAssignment.js | 1 - .../reference/systemExportAssignment.symbols | 5 +- .../reference/systemExportAssignment.types | 1 - .../systemExportAssignment2.errors.txt | 3 +- .../reference/systemExportAssignment2.js | 1 - .../reference/systemExportAssignment3.js | 1 - .../reference/systemExportAssignment3.symbols | 5 +- .../reference/systemExportAssignment3.types | 1 - tests/baselines/reference/systemModule1.js | 1 - .../baselines/reference/systemModule1.symbols | 3 +- tests/baselines/reference/systemModule1.types | 1 - .../reference/systemModule10.errors.txt | 5 +- tests/baselines/reference/systemModule10.js | 1 - .../reference/systemModule10_ES5.errors.txt | 5 +- .../baselines/reference/systemModule10_ES5.js | 1 - .../reference/systemModule11.errors.txt | 17 +- tests/baselines/reference/systemModule11.js | 8 +- .../reference/systemModule12.errors.txt | 3 +- tests/baselines/reference/systemModule12.js | 1 - tests/baselines/reference/systemModule13.js | 1 - .../reference/systemModule13.symbols | 25 +- .../baselines/reference/systemModule13.types | 1 - .../reference/systemModule14.errors.txt | 3 +- tests/baselines/reference/systemModule14.js | 1 - tests/baselines/reference/systemModule15.js | 5 - .../reference/systemModule15.symbols | 55 +- .../baselines/reference/systemModule15.types | 5 - .../reference/systemModule16.errors.txt | 21 +- tests/baselines/reference/systemModule16.js | 1 - tests/baselines/reference/systemModule17.js | 3 - .../reference/systemModule17.symbols | 79 +- .../baselines/reference/systemModule17.types | 3 - .../reference/systemModule2.errors.txt | 3 +- tests/baselines/reference/systemModule2.js | 1 - tests/baselines/reference/systemModule3.js | 5 - .../baselines/reference/systemModule3.symbols | 9 +- tests/baselines/reference/systemModule3.types | 9 +- tests/baselines/reference/systemModule4.js | 1 - .../baselines/reference/systemModule4.symbols | 5 +- tests/baselines/reference/systemModule4.types | 1 - tests/baselines/reference/systemModule5.js | 1 - .../baselines/reference/systemModule5.symbols | 1 - tests/baselines/reference/systemModule5.types | 1 - tests/baselines/reference/systemModule6.js | 1 - .../baselines/reference/systemModule6.symbols | 3 +- tests/baselines/reference/systemModule6.types | 1 - tests/baselines/reference/systemModule7.js | 1 - .../baselines/reference/systemModule7.symbols | 9 +- tests/baselines/reference/systemModule7.types | 1 - tests/baselines/reference/systemModule8.js | 1 - .../baselines/reference/systemModule8.symbols | 75 +- tests/baselines/reference/systemModule8.types | 1 - .../reference/systemModule9.errors.txt | 13 +- tests/baselines/reference/systemModule9.js | 1 - .../systemModuleAmbientDeclarations.js | 1 - .../systemModuleAmbientDeclarations.symbols | 23 +- .../systemModuleAmbientDeclarations.types | 1 - .../reference/systemModuleConstEnums.js | 1 - .../reference/systemModuleConstEnums.symbols | 31 +- .../reference/systemModuleConstEnums.types | 1 - ...stemModuleConstEnumsSeparateCompilation.js | 1 - ...oduleConstEnumsSeparateCompilation.symbols | 31 +- ...mModuleConstEnumsSeparateCompilation.types | 1 - .../systemModuleDeclarationMerging.js | 1 - .../systemModuleDeclarationMerging.symbols | 19 +- .../systemModuleDeclarationMerging.types | 1 - .../reference/systemModuleExportDefault.js | 1 - .../systemModuleExportDefault.symbols | 3 +- .../reference/systemModuleExportDefault.types | 3 +- .../systemModuleNonTopLevelModuleMembers.js | 1 - ...stemModuleNonTopLevelModuleMembers.symbols | 25 +- ...systemModuleNonTopLevelModuleMembers.types | 1 - .../reference/systemModuleWithSuperClass.js | 1 - .../systemModuleWithSuperClass.symbols | 3 +- .../systemModuleWithSuperClass.types | 1 - .../taggedTemplateContextualTyping1.js | 1 - .../taggedTemplateContextualTyping1.symbols | 117 +- .../taggedTemplateContextualTyping1.types | 1 - .../taggedTemplateContextualTyping2.js | 1 - .../taggedTemplateContextualTyping2.symbols | 89 +- .../taggedTemplateContextualTyping2.types | 1 - ...sPlainCharactersThatArePartsOfEscapes01.js | 2 - ...nCharactersThatArePartsOfEscapes01.symbols | 4 +- ...ainCharactersThatArePartsOfEscapes01.types | 2 - ...inCharactersThatArePartsOfEscapes01_ES6.js | 1 - ...ractersThatArePartsOfEscapes01_ES6.symbols | 3 +- ...haractersThatArePartsOfEscapes01_ES6.types | 1 - ...sPlainCharactersThatArePartsOfEscapes02.js | 2 - ...nCharactersThatArePartsOfEscapes02.symbols | 4 +- ...ainCharactersThatArePartsOfEscapes02.types | 2 - ...inCharactersThatArePartsOfEscapes02_ES6.js | 1 - ...ractersThatArePartsOfEscapes02_ES6.symbols | 3 +- ...haractersThatArePartsOfEscapes02_ES6.types | 1 - ...ateStringsTypeArgumentInference.errors.txt | 6 +- ...gedTemplateStringsTypeArgumentInference.js | 2 - ...StringsTypeArgumentInferenceES6.errors.txt | 5 +- ...TemplateStringsTypeArgumentInferenceES6.js | 1 - ...dTemplateStringsWithOverloadResolution2.js | 1 - ...lateStringsWithOverloadResolution2.symbols | 49 +- ...mplateStringsWithOverloadResolution2.types | 1 - ...eStringsWithOverloadResolution3.errors.txt | 13 +- ...dTemplateStringsWithOverloadResolution3.js | 1 - ...aggedTemplateStringsWithTagNamedDeclare.js | 2 - ...TemplateStringsWithTagNamedDeclare.symbols | 6 +- ...edTemplateStringsWithTagNamedDeclare.types | 2 - ...edTemplateStringsWithTagNamedDeclareES6.js | 1 - ...plateStringsWithTagNamedDeclareES6.symbols | 5 +- ...emplateStringsWithTagNamedDeclareES6.types | 1 - ...essionsInSubstitutionExpression.errors.txt | 4 +- ...tionExpressionsInSubstitutionExpression.js | 2 - ...ionsInSubstitutionExpressionES6.errors.txt | 3 +- ...nExpressionsInSubstitutionExpressionES6.js | 1 - ...completeNoSubstitutionTemplate1.errors.txt | 3 +- ...esWithIncompleteNoSubstitutionTemplate1.js | 1 - ...completeNoSubstitutionTemplate2.errors.txt | 3 +- ...esWithIncompleteNoSubstitutionTemplate2.js | 1 - ...hIncompleteTemplateExpressions1.errors.txt | 3 +- ...latesWithIncompleteTemplateExpressions1.js | 1 - ...hIncompleteTemplateExpressions2.errors.txt | 5 +- ...latesWithIncompleteTemplateExpressions2.js | 1 - ...hIncompleteTemplateExpressions3.errors.txt | 5 +- ...latesWithIncompleteTemplateExpressions3.js | 1 - ...hIncompleteTemplateExpressions4.errors.txt | 7 +- ...latesWithIncompleteTemplateExpressions4.js | 1 - ...hIncompleteTemplateExpressions5.errors.txt | 5 +- ...latesWithIncompleteTemplateExpressions5.js | 1 - ...hIncompleteTemplateExpressions6.errors.txt | 5 +- ...latesWithIncompleteTemplateExpressions6.js | 1 - ...templateStringControlCharacterEscapes01.js | 2 - ...ateStringControlCharacterEscapes01.symbols | 4 +- ...plateStringControlCharacterEscapes01.types | 2 - ...lateStringControlCharacterEscapes01_ES6.js | 1 - ...tringControlCharacterEscapes01_ES6.symbols | 3 +- ...eStringControlCharacterEscapes01_ES6.types | 1 - ...templateStringControlCharacterEscapes02.js | 2 - ...ateStringControlCharacterEscapes02.symbols | 4 +- ...plateStringControlCharacterEscapes02.types | 2 - ...lateStringControlCharacterEscapes02_ES6.js | 1 - ...tringControlCharacterEscapes02_ES6.symbols | 3 +- ...eStringControlCharacterEscapes02_ES6.types | 1 - ...templateStringControlCharacterEscapes03.js | 2 - ...ateStringControlCharacterEscapes03.symbols | 4 +- ...plateStringControlCharacterEscapes03.types | 2 - ...lateStringControlCharacterEscapes03_ES6.js | 1 - ...tringControlCharacterEscapes03_ES6.symbols | 3 +- ...eStringControlCharacterEscapes03_ES6.types | 1 - ...templateStringControlCharacterEscapes04.js | 2 - ...ateStringControlCharacterEscapes04.symbols | 4 +- ...plateStringControlCharacterEscapes04.types | 2 - ...lateStringControlCharacterEscapes04_ES6.js | 1 - ...tringControlCharacterEscapes04_ES6.symbols | 3 +- ...eStringControlCharacterEscapes04_ES6.types | 1 - .../reference/templateStringMultiline1.js | 2 - .../templateStringMultiline1.symbols | 4 +- .../reference/templateStringMultiline1.types | 2 - .../reference/templateStringMultiline1_ES6.js | 1 - .../templateStringMultiline1_ES6.symbols | 3 +- .../templateStringMultiline1_ES6.types | 1 - .../reference/templateStringMultiline2.js | 2 - .../templateStringMultiline2.symbols | 4 +- .../reference/templateStringMultiline2.types | 2 - .../reference/templateStringMultiline2_ES6.js | 1 - .../templateStringMultiline2_ES6.symbols | 3 +- .../templateStringMultiline2_ES6.types | 1 - .../reference/templateStringMultiline3.js | 2 - .../templateStringMultiline3.symbols | 4 +- .../reference/templateStringMultiline3.types | 2 - .../reference/templateStringMultiline3_ES6.js | 1 - .../templateStringMultiline3_ES6.symbols | 3 +- .../templateStringMultiline3_ES6.types | 1 - ...gPlainCharactersThatArePartsOfEscapes01.js | 1 - ...nCharactersThatArePartsOfEscapes01.symbols | 3 +- ...ainCharactersThatArePartsOfEscapes01.types | 1 - ...inCharactersThatArePartsOfEscapes01_ES6.js | 1 - ...ractersThatArePartsOfEscapes01_ES6.symbols | 3 +- ...haractersThatArePartsOfEscapes01_ES6.types | 1 - ...gPlainCharactersThatArePartsOfEscapes02.js | 2 - ...nCharactersThatArePartsOfEscapes02.symbols | 4 +- ...ainCharactersThatArePartsOfEscapes02.types | 2 - ...inCharactersThatArePartsOfEscapes02_ES6.js | 1 - ...ractersThatArePartsOfEscapes02_ES6.symbols | 3 +- ...haractersThatArePartsOfEscapes02_ES6.types | 1 - .../reference/templateStringTermination1.js | 1 - .../templateStringTermination1.symbols | 3 +- .../templateStringTermination1.types | 1 - .../reference/templateStringTermination2.js | 1 - .../templateStringTermination2.symbols | 3 +- .../templateStringTermination2.types | 1 - .../reference/templateStringTermination3.js | 1 - .../templateStringTermination3.symbols | 3 +- .../templateStringTermination3.types | 1 - .../reference/templateStringTermination4.js | 1 - .../templateStringTermination4.symbols | 3 +- .../templateStringTermination4.types | 1 - .../reference/templateStringTermination5.js | 1 - .../templateStringTermination5.symbols | 3 +- .../templateStringTermination5.types | 1 - .../templateStringUnterminated1.errors.txt | 3 +- .../reference/templateStringUnterminated1.js | 1 - .../templateStringUnterminated2.errors.txt | 3 +- .../reference/templateStringUnterminated2.js | 1 - .../templateStringUnterminated3.errors.txt | 3 +- .../reference/templateStringUnterminated3.js | 1 - .../templateStringUnterminated4.errors.txt | 3 +- .../reference/templateStringUnterminated4.js | 1 - .../templateStringUnterminated5.errors.txt | 3 +- .../reference/templateStringUnterminated5.js | 1 - .../templateStringWhitespaceEscapes1.js | 2 - .../templateStringWhitespaceEscapes1.symbols | 4 +- .../templateStringWhitespaceEscapes1.types | 2 - .../templateStringWhitespaceEscapes1_ES6.js | 1 - ...mplateStringWhitespaceEscapes1_ES6.symbols | 3 +- ...templateStringWhitespaceEscapes1_ES6.types | 1 - .../templateStringWhitespaceEscapes2.js | 2 - .../templateStringWhitespaceEscapes2.symbols | 4 +- .../templateStringWhitespaceEscapes2.types | 2 - .../templateStringWhitespaceEscapes2_ES6.js | 1 - ...mplateStringWhitespaceEscapes2_ES6.symbols | 3 +- ...templateStringWhitespaceEscapes2_ES6.types | 1 - .../templateStringWithBackslashEscapes01.js | 2 - ...mplateStringWithBackslashEscapes01.symbols | 10 +- ...templateStringWithBackslashEscapes01.types | 2 - ...emplateStringWithBackslashEscapes01_ES6.js | 1 - ...teStringWithBackslashEscapes01_ES6.symbols | 9 +- ...lateStringWithBackslashEscapes01_ES6.types | 1 - ...tringsArrayTypeDefinedInES5Mode.errors.txt | 3 +- ...emplateStringsArrayTypeDefinedInES5Mode.js | 1 - ...ringsArrayTypeNotDefinedES5Mode.errors.txt | 3 +- ...mplateStringsArrayTypeNotDefinedES5Mode.js | 1 - ...ingsArrayTypeRedefinedInES6Mode.errors.txt | 3 +- ...plateStringsArrayTypeRedefinedInES6Mode.js | 1 - ...essionsInSubstitutionExpression.errors.txt | 4 +- ...tionExpressionsInSubstitutionExpression.js | 2 - ...ionsInSubstitutionExpressionES6.errors.txt | 3 +- ...nExpressionsInSubstitutionExpressionES6.js | 1 - .../reference/ternaryExpressionSourceMap.js | 1 - .../ternaryExpressionSourceMap.js.map | 2 +- .../ternaryExpressionSourceMap.sourcemap.txt | 51 +- .../ternaryExpressionSourceMap.symbols | 7 +- .../ternaryExpressionSourceMap.types | 1 - ...BasePropertyAndDerivedContainerOfBase01.js | 1 - ...ropertyAndDerivedContainerOfBase01.symbols | 19 +- ...ePropertyAndDerivedContainerOfBase01.types | 1 - .../reference/throwInEnclosingStatements.js | 1 - .../throwInEnclosingStatements.symbols | 65 +- .../throwInEnclosingStatements.types | 1 - tests/baselines/reference/throwStatements.js | 1 - .../reference/throwStatements.symbols | 155 +- .../baselines/reference/throwStatements.types | 1 - .../baselines/reference/trailingCommasES3.js | 1 - .../reference/trailingCommasES3.symbols | 31 +- .../reference/trailingCommasES3.types | 1 - .../baselines/reference/trailingCommasES5.js | 1 - .../reference/trailingCommasES5.symbols | 31 +- .../reference/trailingCommasES5.types | 1 - ...gCommasInFunctionParametersAndArguments.js | 1 - ...asInFunctionParametersAndArguments.symbols | 39 +- ...mmasInFunctionParametersAndArguments.types | 1 - ...ormArrowInBlockScopedLoopVarInitializer.js | 1 - ...rowInBlockScopedLoopVarInitializer.symbols | 7 +- ...ArrowInBlockScopedLoopVarInitializer.types | 1 - .../transformsElideNullUndefinedType.js | 1 - .../transformsElideNullUndefinedType.symbols | 111 +- .../transformsElideNullUndefinedType.types | 1 - .../reference/tsxAttributeErrors.errors.txt | 7 +- .../baselines/reference/tsxAttributeErrors.js | 1 - .../reference/tsxAttributeResolution.js | 1 - .../reference/tsxAttributeResolution.symbols | 9 +- .../reference/tsxAttributeResolution.types | 1 - .../tsxAttributeResolution10.errors.txt | 1 - .../reference/tsxAttributeResolution10.js | 1 - .../tsxAttributeResolution11.errors.txt | 1 - .../reference/tsxAttributeResolution11.js | 1 - .../tsxAttributeResolution12.errors.txt | 6 +- .../reference/tsxAttributeResolution12.js | 2 - .../reference/tsxAttributeResolution13.js | 1 - .../tsxAttributeResolution13.symbols | 1 - .../reference/tsxAttributeResolution13.types | 1 - .../tsxAttributeResolution14.errors.txt | 6 +- .../reference/tsxAttributeResolution14.js | 2 - .../tsxAttributeResolution15.errors.txt | 3 +- .../reference/tsxAttributeResolution15.js | 1 - .../reference/tsxAttributeResolution16.js | 1 - .../tsxAttributeResolution16.symbols | 41 +- .../reference/tsxAttributeResolution16.types | 1 - .../tsxAttributeResolution9.errors.txt | 1 - .../reference/tsxAttributeResolution9.js | 1 - .../tsxDefaultAttributesResolution1.js | 1 - .../tsxDefaultAttributesResolution1.symbols | 17 +- .../tsxDefaultAttributesResolution1.types | 1 - .../tsxDefaultAttributesResolution2.js | 1 - .../tsxDefaultAttributesResolution2.symbols | 17 +- .../tsxDefaultAttributesResolution2.types | 1 - ...tsxDefaultAttributesResolution3.errors.txt | 3 +- .../tsxDefaultAttributesResolution3.js | 1 - .../baselines/reference/tsxDefaultImports.js | 1 - .../reference/tsxDefaultImports.symbols | 15 +- .../reference/tsxDefaultImports.types | 1 - .../baselines/reference/tsxDynamicTagName1.js | 1 - .../reference/tsxDynamicTagName1.symbols | 7 +- .../reference/tsxDynamicTagName1.types | 1 - .../reference/tsxDynamicTagName2.errors.txt | 5 +- .../baselines/reference/tsxDynamicTagName2.js | 1 - .../reference/tsxDynamicTagName3.errors.txt | 3 +- .../baselines/reference/tsxDynamicTagName3.js | 1 - .../baselines/reference/tsxDynamicTagName4.js | 1 - .../reference/tsxDynamicTagName4.symbols | 15 +- .../reference/tsxDynamicTagName4.types | 1 - .../baselines/reference/tsxDynamicTagName5.js | 1 - .../reference/tsxDynamicTagName5.symbols | 11 +- .../reference/tsxDynamicTagName5.types | 1 - .../baselines/reference/tsxDynamicTagName6.js | 1 - .../reference/tsxDynamicTagName6.symbols | 19 +- .../reference/tsxDynamicTagName6.types | 1 - .../reference/tsxDynamicTagName7.errors.txt | 1 - .../baselines/reference/tsxDynamicTagName7.js | 1 - .../baselines/reference/tsxDynamicTagName8.js | 1 - .../reference/tsxDynamicTagName8.symbols | 11 +- .../reference/tsxDynamicTagName8.types | 1 - .../baselines/reference/tsxDynamicTagName9.js | 1 - .../reference/tsxDynamicTagName9.symbols | 11 +- .../reference/tsxDynamicTagName9.types | 1 - .../reference/tsxElementResolution.js | 1 - .../reference/tsxElementResolution.symbols | 37 +- .../reference/tsxElementResolution.types | 1 - .../reference/tsxElementResolution17.js | 1 - .../reference/tsxElementResolution17.symbols | 13 +- .../reference/tsxElementResolution17.types | 1 - .../reference/tsxElementResolution19.js | 2 - .../reference/tsxElementResolution19.symbols | 10 +- .../reference/tsxElementResolution19.types | 4 +- tests/baselines/reference/tsxEmit3.errors.txt | 9 +- tests/baselines/reference/tsxEmit3.js | 1 - tests/baselines/reference/tsxEmit3.js.map | 2 +- .../reference/tsxEmit3.sourcemap.txt | 349 +- .../reference/tsxErrorRecovery1.errors.txt | 11 +- .../baselines/reference/tsxErrorRecovery1.js | 1 - .../reference/tsxErrorRecovery2.errors.txt | 5 +- .../baselines/reference/tsxErrorRecovery2.js | 1 - .../reference/tsxErrorRecovery3.errors.txt | 7 +- .../baselines/reference/tsxErrorRecovery3.js | 1 - .../reference/tsxExternalModuleEmit1.js | 1 - .../reference/tsxExternalModuleEmit1.symbols | 15 +- .../reference/tsxExternalModuleEmit1.types | 1 - .../reference/tsxExternalModuleEmit2.js | 1 - .../reference/tsxExternalModuleEmit2.symbols | 5 +- .../reference/tsxExternalModuleEmit2.types | 1 - .../baselines/reference/tsxInArrowFunction.js | 1 - .../reference/tsxInArrowFunction.symbols | 45 +- .../reference/tsxInArrowFunction.types | 1 - tests/baselines/reference/tsxNoJsx.js | 1 - tests/baselines/reference/tsxNoJsx.symbols | 1 - tests/baselines/reference/tsxNoJsx.types | 1 - tests/baselines/reference/tsxPreserveEmit1.js | 1 - .../reference/tsxPreserveEmit1.symbols | 15 +- .../reference/tsxPreserveEmit1.types | 1 - tests/baselines/reference/tsxPreserveEmit2.js | 2 - .../reference/tsxPreserveEmit2.symbols | 8 +- .../reference/tsxPreserveEmit2.types | 2 - tests/baselines/reference/tsxPreserveEmit3.js | 1 - .../reference/tsxPreserveEmit3.symbols | 7 +- .../reference/tsxPreserveEmit3.types | 1 - tests/baselines/reference/tsxReactEmit3.js | 1 - .../baselines/reference/tsxReactEmit3.symbols | 25 +- tests/baselines/reference/tsxReactEmit3.types | 1 - tests/baselines/reference/tsxReactEmit5.js | 1 - .../baselines/reference/tsxReactEmit5.symbols | 9 +- tests/baselines/reference/tsxReactEmit5.types | 1 - tests/baselines/reference/tsxReactEmit6.js | 1 - .../baselines/reference/tsxReactEmit6.symbols | 13 +- tests/baselines/reference/tsxReactEmit6.types | 1 - .../reference/tsxReactEmit7.errors.txt | 5 +- tests/baselines/reference/tsxReactEmit7.js | 1 - .../reference/tsxReactEmitNesting.js | 1 - .../reference/tsxReactEmitNesting.symbols | 107 +- .../reference/tsxReactEmitNesting.types | 1 - .../tsxSpreadAttributesResolution1.js | 1 - .../tsxSpreadAttributesResolution1.symbols | 17 +- .../tsxSpreadAttributesResolution1.types | 1 - ...tsxSpreadAttributesResolution10.errors.txt | 9 +- .../tsxSpreadAttributesResolution10.js | 1 - .../tsxSpreadAttributesResolution11.js | 1 - .../tsxSpreadAttributesResolution11.symbols | 99 +- .../tsxSpreadAttributesResolution11.types | 1 - ...tsxSpreadAttributesResolution12.errors.txt | 5 +- .../tsxSpreadAttributesResolution12.js | 1 - .../tsxSpreadAttributesResolution2.errors.txt | 7 +- .../tsxSpreadAttributesResolution2.js | 1 - .../tsxSpreadAttributesResolution3.js | 1 - .../tsxSpreadAttributesResolution3.symbols | 33 +- .../tsxSpreadAttributesResolution3.types | 1 - .../tsxSpreadAttributesResolution4.js | 1 - .../tsxSpreadAttributesResolution4.symbols | 63 +- .../tsxSpreadAttributesResolution4.types | 1 - .../tsxSpreadAttributesResolution5.errors.txt | 5 +- .../tsxSpreadAttributesResolution5.js | 1 - .../tsxSpreadAttributesResolution6.errors.txt | 3 +- .../tsxSpreadAttributesResolution6.js | 1 - .../tsxSpreadAttributesResolution7.js | 1 - .../tsxSpreadAttributesResolution7.symbols | 43 +- .../tsxSpreadAttributesResolution7.types | 1 - .../tsxSpreadAttributesResolution8.js | 1 - .../tsxSpreadAttributesResolution8.symbols | 47 +- .../tsxSpreadAttributesResolution8.types | 1 - .../tsxSpreadAttributesResolution9.js | 1 - .../tsxSpreadAttributesResolution9.symbols | 53 +- .../tsxSpreadAttributesResolution9.types | 1 - .../baselines/reference/tsxSpreadChildren.js | 1 - .../reference/tsxSpreadChildren.symbols | 85 +- .../reference/tsxSpreadChildren.types | 1 - .../tsxStatelessFunctionComponentOverload1.js | 1 - ...tatelessFunctionComponentOverload1.symbols | 189 +- ...xStatelessFunctionComponentOverload1.types | 1 - .../tsxStatelessFunctionComponentOverload2.js | 1 - ...tatelessFunctionComponentOverload2.symbols | 97 +- ...xStatelessFunctionComponentOverload2.types | 1 - .../tsxStatelessFunctionComponentOverload3.js | 1 - ...tatelessFunctionComponentOverload3.symbols | 97 +- ...xStatelessFunctionComponentOverload3.types | 1 - ...elessFunctionComponentOverload4.errors.txt | 21 +- .../tsxStatelessFunctionComponentOverload4.js | 1 - ...elessFunctionComponentOverload5.errors.txt | 17 +- .../tsxStatelessFunctionComponentOverload5.js | 1 - .../tsxStatelessFunctionComponentOverload6.js | 1 - ...tatelessFunctionComponentOverload6.symbols | 183 +- ...xStatelessFunctionComponentOverload6.types | 1 - ...tsxStatelessFunctionComponents1.errors.txt | 17 +- .../tsxStatelessFunctionComponents1.js | 1 - ...tsxStatelessFunctionComponents2.errors.txt | 9 +- .../tsxStatelessFunctionComponents2.js | 1 - .../tsxStatelessFunctionComponents3.js | 1 - .../tsxStatelessFunctionComponents3.symbols | 21 +- .../tsxStatelessFunctionComponents3.types | 1 - ...essFunctionComponentsWithTypeArguments1.js | 1 - ...nctionComponentsWithTypeArguments1.symbols | 129 +- ...FunctionComponentsWithTypeArguments1.types | 1 - ...ionComponentsWithTypeArguments2.errors.txt | 11 +- ...essFunctionComponentsWithTypeArguments2.js | 1 - ...ionComponentsWithTypeArguments3.errors.txt | 5 +- ...essFunctionComponentsWithTypeArguments3.js | 1 - ...ionComponentsWithTypeArguments4.errors.txt | 5 +- ...essFunctionComponentsWithTypeArguments4.js | 1 - ...ionComponentsWithTypeArguments5.errors.txt | 9 +- ...essFunctionComponentsWithTypeArguments5.js | 1 - tests/baselines/reference/tsxTypeErrors.js | 1 - .../baselines/reference/tsxTypeErrors.symbols | 53 +- tests/baselines/reference/tsxTypeErrors.types | 1 - .../reference/tsxUnionElementType1.js | 1 - .../reference/tsxUnionElementType1.symbols | 23 +- .../reference/tsxUnionElementType1.types | 1 - .../reference/tsxUnionElementType2.errors.txt | 3 +- .../reference/tsxUnionElementType2.js | 1 - .../reference/tsxUnionElementType3.js | 1 - .../reference/tsxUnionElementType3.symbols | 67 +- .../reference/tsxUnionElementType3.types | 1 - .../reference/tsxUnionElementType4.errors.txt | 7 +- .../reference/tsxUnionElementType4.js | 1 - .../reference/tsxUnionElementType5.js | 1 - .../reference/tsxUnionElementType5.symbols | 39 +- .../reference/tsxUnionElementType5.types | 1 - .../reference/tsxUnionElementType6.errors.txt | 9 +- .../reference/tsxUnionElementType6.js | 1 - .../reference/tsxUnionTypeComponent1.js | 1 - .../reference/tsxUnionTypeComponent1.symbols | 29 +- .../reference/tsxUnionTypeComponent1.types | 1 - .../tsxUnionTypeComponent2.errors.txt | 3 +- .../reference/tsxUnionTypeComponent2.js | 1 - .../typeAliasDeclarationEmit.errors.txt | 3 +- .../reference/typeAliasDeclarationEmit.js | 1 - .../reference/typeAliasDeclarationEmit2.js | 1 - .../typeAliasDeclarationEmit2.symbols | 7 +- .../reference/typeAliasDeclarationEmit2.types | 1 - ...eArgumentInferenceTransitiveConstraints.js | 1 - ...mentInferenceTransitiveConstraints.symbols | 33 +- ...gumentInferenceTransitiveConstraints.types | 1 - ...gumentsWithStringLiteralTypes01.errors.txt | 33 +- .../typeArgumentsWithStringLiteralTypes01.js | 1 - .../typeCheckTypeArgument.errors.txt | 13 +- .../reference/typeCheckTypeArgument.js | 1 - .../baselines/reference/typeGuardFunction.js | 1 - .../reference/typeGuardFunction.symbols | 193 +- .../reference/typeGuardFunction.types | 1 - .../typeGuardFunctionErrors.errors.txt | 109 +- .../reference/typeGuardFunctionErrors.js | 1 - .../reference/typeGuardFunctionGenerics.js | 1 - .../typeGuardFunctionGenerics.symbols | 137 +- .../reference/typeGuardFunctionGenerics.types | 1 - .../reference/typeGuardIntersectionTypes.js | 1 - .../typeGuardIntersectionTypes.symbols | 235 +- .../typeGuardIntersectionTypes.types | 1 - .../reference/typeGuardOfFormIsType.js | 1 - .../reference/typeGuardOfFormIsType.symbols | 145 +- .../reference/typeGuardOfFormIsType.types | 1 - .../typeGuardOfFormIsTypeOnInterfaces.js | 1 - .../typeGuardOfFormIsTypeOnInterfaces.symbols | 167 +- .../typeGuardOfFormIsTypeOnInterfaces.types | 1 - .../reference/typeGuardsAsAssertions.js | 1 - .../reference/typeGuardsAsAssertions.symbols | 231 +- .../reference/typeGuardsAsAssertions.types | 1 - .../reference/typeGuardsInClassAccessors.js | 1 - .../typeGuardsInClassAccessors.symbols | 177 +- .../typeGuardsInClassAccessors.types | 1 - .../reference/typeGuardsInProperties.js | 1 - .../reference/typeGuardsInProperties.symbols | 109 +- .../reference/typeGuardsInProperties.types | 1 - .../reference/typeGuardsNestedAssignments.js | 1 - .../typeGuardsNestedAssignments.symbols | 69 +- .../typeGuardsNestedAssignments.types | 1 - .../reference/typeGuardsObjectMethods.js | 1 - .../reference/typeGuardsObjectMethods.symbols | 109 +- .../reference/typeGuardsObjectMethods.types | 1 - ...redicateOnVariableDeclaration01.errors.txt | 3 +- .../typePredicateOnVariableDeclaration01.js | 1 - ...redicateOnVariableDeclaration02.errors.txt | 11 +- .../typePredicateOnVariableDeclaration02.js | 1 - .../reference/typeReferenceDirectives1.js | 1 - .../typeReferenceDirectives1.symbols | 3 +- .../reference/typeReferenceDirectives1.types | 1 - .../reference/typeReferenceDirectives10.js | 1 - .../typeReferenceDirectives10.symbols | 3 +- .../reference/typeReferenceDirectives10.types | 1 - .../typeReferenceDirectives11.errors.txt | 7 +- .../typeReferenceDirectives12.errors.txt | 3 - .../reference/typeReferenceDirectives13.js | 1 - .../typeReferenceDirectives13.symbols | 3 +- .../reference/typeReferenceDirectives13.types | 1 - .../reference/typeReferenceDirectives2.js | 1 - .../typeReferenceDirectives2.symbols | 3 +- .../reference/typeReferenceDirectives2.types | 1 - .../reference/typeReferenceDirectives3.js | 1 - .../typeReferenceDirectives3.symbols | 3 +- .../reference/typeReferenceDirectives3.types | 1 - .../reference/typeReferenceDirectives4.js | 1 - .../typeReferenceDirectives4.symbols | 3 +- .../reference/typeReferenceDirectives4.types | 1 - .../reference/typeReferenceDirectives5.js | 1 - .../typeReferenceDirectives5.symbols | 3 +- .../reference/typeReferenceDirectives5.types | 1 - .../reference/typeReferenceDirectives6.js | 1 - .../typeReferenceDirectives6.symbols | 9 +- .../reference/typeReferenceDirectives6.types | 1 - .../reference/typeReferenceDirectives7.js | 1 - .../typeReferenceDirectives7.symbols | 5 +- .../reference/typeReferenceDirectives7.types | 1 - .../reference/typeReferenceDirectives8.js | 4 - .../typeReferenceDirectives8.symbols | 14 +- .../reference/typeReferenceDirectives8.types | 4 - .../reference/typeReferenceDirectives9.js | 2 - .../typeReferenceDirectives9.symbols | 4 +- .../reference/typeReferenceDirectives9.types | 2 - ...RootsFromMultipleNodeModulesDirectories.js | 1 - ...FromMultipleNodeModulesDirectories.symbols | 3 +- ...tsFromMultipleNodeModulesDirectories.types | 1 - ...peRootsFromNodeModulesInParentDirectory.js | 1 - ...tsFromNodeModulesInParentDirectory.symbols | 3 +- ...ootsFromNodeModulesInParentDirectory.types | 1 - tests/baselines/reference/typedArrays.js | 1 - tests/baselines/reference/typedArrays.symbols | 423 ++- tests/baselines/reference/typedArrays.types | 1 - ...typedArraysCrossAssignability01.errors.txt | 129 +- .../typedArraysCrossAssignability01.js | 1 - .../typeofOperatorWithBooleanType.errors.txt | 3 +- .../typeofOperatorWithBooleanType.js | 1 - .../typeofOperatorWithEnumType.errors.txt | 3 +- .../reference/typeofOperatorWithEnumType.js | 1 - .../reference/typeofProperty.errors.txt | 13 +- tests/baselines/reference/typeofProperty.js | 1 - tests/baselines/reference/typeofStrictNull.js | 1 - .../reference/typeofStrictNull.symbols | 7 +- .../reference/typeofStrictNull.types | 1 - tests/baselines/reference/typeofUndefined.js | 1 - .../reference/typeofUndefined.symbols | 5 +- .../baselines/reference/typeofUndefined.types | 1 - .../typesWithPrivateConstructor.errors.txt | 5 +- .../reference/typesWithPrivateConstructor.js | 1 - .../typesWithProtectedConstructor.errors.txt | 5 +- .../typesWithProtectedConstructor.js | 1 - tests/baselines/reference/typingsLookupAmd.js | 1 - .../reference/typingsLookupAmd.symbols | 1 - .../reference/typingsLookupAmd.types | 1 - .../baselines/reference/umd-augmentation-1.js | 1 - .../reference/umd-augmentation-1.symbols | 55 +- .../reference/umd-augmentation-1.types | 1 - .../baselines/reference/umd-augmentation-2.js | 1 - .../reference/umd-augmentation-2.symbols | 55 +- .../reference/umd-augmentation-2.types | 1 - .../baselines/reference/umd-augmentation-3.js | 1 - .../reference/umd-augmentation-3.symbols | 59 +- .../reference/umd-augmentation-3.types | 1 - .../baselines/reference/umd-augmentation-4.js | 1 - .../reference/umd-augmentation-4.symbols | 59 +- .../reference/umd-augmentation-4.types | 1 - .../baselines/reference/umd-errors.errors.txt | 3 +- tests/baselines/reference/umd-errors.js | 1 - tests/baselines/reference/umd1.js | 1 - tests/baselines/reference/umd1.symbols | 27 +- tests/baselines/reference/umd1.types | 1 - tests/baselines/reference/umd2.errors.txt | 1 - tests/baselines/reference/umd2.js | 1 - tests/baselines/reference/umd3.js | 1 - tests/baselines/reference/umd3.symbols | 23 +- tests/baselines/reference/umd3.types | 1 - tests/baselines/reference/umd4.js | 1 - tests/baselines/reference/umd4.symbols | 23 +- tests/baselines/reference/umd4.types | 1 - tests/baselines/reference/umd5.errors.txt | 1 - tests/baselines/reference/umd5.js | 1 - tests/baselines/reference/umd6.js | 1 - tests/baselines/reference/umd6.symbols | 11 +- tests/baselines/reference/umd6.types | 1 - tests/baselines/reference/umd7.js | 1 - tests/baselines/reference/umd7.symbols | 5 +- tests/baselines/reference/umd7.types | 1 - tests/baselines/reference/umd8.errors.txt | 1 - tests/baselines/reference/umd8.js | 1 - .../unclosedExportClause01.errors.txt | 1 - .../reference/unclosedExportClause01.js | 1 - .../unclosedExportClause02.errors.txt | 1 - .../reference/unclosedExportClause02.js | 1 - .../reference/undeclaredMethod.errors.txt | 3 +- tests/baselines/reference/undeclaredMethod.js | 1 - ...tendedEscapesInRegularExpressions01_ES5.js | 1 - ...dEscapesInRegularExpressions01_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions01_ES5.types | 1 - ...tendedEscapesInRegularExpressions01_ES6.js | 1 - ...dEscapesInRegularExpressions01_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions01_ES6.types | 1 - ...tendedEscapesInRegularExpressions02_ES5.js | 1 - ...dEscapesInRegularExpressions02_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions02_ES5.types | 1 - ...tendedEscapesInRegularExpressions02_ES6.js | 1 - ...dEscapesInRegularExpressions02_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions02_ES6.types | 1 - ...tendedEscapesInRegularExpressions03_ES5.js | 1 - ...dEscapesInRegularExpressions03_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions03_ES5.types | 1 - ...tendedEscapesInRegularExpressions03_ES6.js | 1 - ...dEscapesInRegularExpressions03_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions03_ES6.types | 1 - ...tendedEscapesInRegularExpressions04_ES5.js | 1 - ...dEscapesInRegularExpressions04_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions04_ES5.types | 1 - ...tendedEscapesInRegularExpressions04_ES6.js | 1 - ...dEscapesInRegularExpressions04_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions04_ES6.types | 1 - ...tendedEscapesInRegularExpressions05_ES5.js | 1 - ...dEscapesInRegularExpressions05_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions05_ES5.types | 1 - ...tendedEscapesInRegularExpressions05_ES6.js | 1 - ...dEscapesInRegularExpressions05_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions05_ES6.types | 1 - ...tendedEscapesInRegularExpressions06_ES5.js | 1 - ...dEscapesInRegularExpressions06_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions06_ES5.types | 1 - ...tendedEscapesInRegularExpressions06_ES6.js | 1 - ...dEscapesInRegularExpressions06_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions06_ES6.types | 1 - ...tendedEscapesInRegularExpressions07_ES5.js | 1 - ...dEscapesInRegularExpressions07_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions07_ES5.types | 1 - ...tendedEscapesInRegularExpressions07_ES6.js | 1 - ...dEscapesInRegularExpressions07_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions07_ES6.types | 1 - ...tendedEscapesInRegularExpressions08_ES5.js | 1 - ...dEscapesInRegularExpressions08_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions08_ES5.types | 1 - ...tendedEscapesInRegularExpressions08_ES6.js | 1 - ...dEscapesInRegularExpressions08_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions08_ES6.types | 1 - ...tendedEscapesInRegularExpressions09_ES5.js | 1 - ...dEscapesInRegularExpressions09_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions09_ES5.types | 1 - ...tendedEscapesInRegularExpressions09_ES6.js | 1 - ...dEscapesInRegularExpressions09_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions09_ES6.types | 1 - ...tendedEscapesInRegularExpressions10_ES5.js | 1 - ...dEscapesInRegularExpressions10_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions10_ES5.types | 1 - ...tendedEscapesInRegularExpressions10_ES6.js | 1 - ...dEscapesInRegularExpressions10_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions10_ES6.types | 1 - ...tendedEscapesInRegularExpressions11_ES5.js | 1 - ...dEscapesInRegularExpressions11_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions11_ES5.types | 1 - ...tendedEscapesInRegularExpressions11_ES6.js | 1 - ...dEscapesInRegularExpressions11_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions11_ES6.types | 1 - ...tendedEscapesInRegularExpressions12_ES5.js | 1 - ...dEscapesInRegularExpressions12_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions12_ES5.types | 1 - ...tendedEscapesInRegularExpressions12_ES6.js | 1 - ...dEscapesInRegularExpressions12_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions12_ES6.types | 1 - ...tendedEscapesInRegularExpressions13_ES5.js | 1 - ...dEscapesInRegularExpressions13_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions13_ES5.types | 1 - ...tendedEscapesInRegularExpressions13_ES6.js | 1 - ...dEscapesInRegularExpressions13_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions13_ES6.types | 1 - ...tendedEscapesInRegularExpressions14_ES5.js | 1 - ...dEscapesInRegularExpressions14_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions14_ES5.types | 1 - ...tendedEscapesInRegularExpressions14_ES6.js | 1 - ...dEscapesInRegularExpressions14_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions14_ES6.types | 1 - ...tendedEscapesInRegularExpressions15_ES5.js | 1 - ...dEscapesInRegularExpressions15_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions15_ES5.types | 1 - ...tendedEscapesInRegularExpressions15_ES6.js | 1 - ...dEscapesInRegularExpressions15_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions15_ES6.types | 1 - ...tendedEscapesInRegularExpressions16_ES5.js | 1 - ...dEscapesInRegularExpressions16_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions16_ES5.types | 1 - ...tendedEscapesInRegularExpressions16_ES6.js | 1 - ...dEscapesInRegularExpressions16_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions16_ES6.types | 1 - ...tendedEscapesInRegularExpressions17_ES5.js | 1 - ...dEscapesInRegularExpressions17_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions17_ES5.types | 1 - ...tendedEscapesInRegularExpressions17_ES6.js | 1 - ...dEscapesInRegularExpressions17_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions17_ES6.types | 1 - ...tendedEscapesInRegularExpressions18_ES5.js | 1 - ...dEscapesInRegularExpressions18_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions18_ES5.types | 1 - ...tendedEscapesInRegularExpressions18_ES6.js | 1 - ...dEscapesInRegularExpressions18_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions18_ES6.types | 1 - ...tendedEscapesInRegularExpressions19_ES5.js | 1 - ...dEscapesInRegularExpressions19_ES5.symbols | 3 +- ...dedEscapesInRegularExpressions19_ES5.types | 1 - ...tendedEscapesInRegularExpressions19_ES6.js | 1 - ...dEscapesInRegularExpressions19_ES6.symbols | 3 +- ...dedEscapesInRegularExpressions19_ES6.types | 1 - .../unicodeExtendedEscapesInStrings01_ES5.js | 1 - ...codeExtendedEscapesInStrings01_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings01_ES5.types | 1 - .../unicodeExtendedEscapesInStrings01_ES6.js | 1 - ...codeExtendedEscapesInStrings01_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings01_ES6.types | 1 - .../unicodeExtendedEscapesInStrings02_ES5.js | 1 - ...codeExtendedEscapesInStrings02_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings02_ES5.types | 1 - .../unicodeExtendedEscapesInStrings02_ES6.js | 1 - ...codeExtendedEscapesInStrings02_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings02_ES6.types | 1 - .../unicodeExtendedEscapesInStrings03_ES5.js | 1 - ...codeExtendedEscapesInStrings03_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings03_ES5.types | 1 - .../unicodeExtendedEscapesInStrings03_ES6.js | 1 - ...codeExtendedEscapesInStrings03_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings03_ES6.types | 1 - .../unicodeExtendedEscapesInStrings04_ES5.js | 1 - ...codeExtendedEscapesInStrings04_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings04_ES5.types | 1 - .../unicodeExtendedEscapesInStrings04_ES6.js | 1 - ...codeExtendedEscapesInStrings04_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings04_ES6.types | 1 - .../unicodeExtendedEscapesInStrings05_ES5.js | 1 - ...codeExtendedEscapesInStrings05_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings05_ES5.types | 1 - .../unicodeExtendedEscapesInStrings05_ES6.js | 1 - ...codeExtendedEscapesInStrings05_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings05_ES6.types | 1 - .../unicodeExtendedEscapesInStrings06_ES5.js | 1 - ...codeExtendedEscapesInStrings06_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings06_ES5.types | 1 - .../unicodeExtendedEscapesInStrings06_ES6.js | 1 - ...codeExtendedEscapesInStrings06_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings06_ES6.types | 1 - ...eExtendedEscapesInStrings07_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings07_ES5.js | 1 - ...eExtendedEscapesInStrings07_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings07_ES6.js | 1 - .../unicodeExtendedEscapesInStrings08_ES5.js | 1 - ...codeExtendedEscapesInStrings08_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings08_ES5.types | 1 - .../unicodeExtendedEscapesInStrings08_ES6.js | 1 - ...codeExtendedEscapesInStrings08_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings08_ES6.types | 1 - .../unicodeExtendedEscapesInStrings09_ES5.js | 1 - ...codeExtendedEscapesInStrings09_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings09_ES5.types | 1 - .../unicodeExtendedEscapesInStrings09_ES6.js | 1 - ...codeExtendedEscapesInStrings09_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings09_ES6.types | 1 - .../unicodeExtendedEscapesInStrings10_ES5.js | 1 - ...codeExtendedEscapesInStrings10_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings10_ES5.types | 1 - .../unicodeExtendedEscapesInStrings10_ES6.js | 1 - ...codeExtendedEscapesInStrings10_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings10_ES6.types | 1 - .../unicodeExtendedEscapesInStrings11_ES5.js | 1 - ...codeExtendedEscapesInStrings11_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings11_ES5.types | 1 - .../unicodeExtendedEscapesInStrings11_ES6.js | 1 - ...codeExtendedEscapesInStrings11_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings11_ES6.types | 1 - ...eExtendedEscapesInStrings12_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings12_ES5.js | 1 - ...eExtendedEscapesInStrings12_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings12_ES6.js | 1 - .../unicodeExtendedEscapesInStrings13_ES5.js | 1 - ...codeExtendedEscapesInStrings13_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings13_ES5.types | 1 - .../unicodeExtendedEscapesInStrings13_ES6.js | 1 - ...codeExtendedEscapesInStrings13_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings13_ES6.types | 1 - ...eExtendedEscapesInStrings14_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings14_ES5.js | 1 - ...eExtendedEscapesInStrings14_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings14_ES6.js | 1 - .../unicodeExtendedEscapesInStrings15_ES5.js | 1 - ...codeExtendedEscapesInStrings15_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings15_ES5.types | 1 - .../unicodeExtendedEscapesInStrings15_ES6.js | 1 - ...codeExtendedEscapesInStrings15_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings15_ES6.types | 1 - .../unicodeExtendedEscapesInStrings16_ES5.js | 1 - ...codeExtendedEscapesInStrings16_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings16_ES5.types | 1 - .../unicodeExtendedEscapesInStrings16_ES6.js | 1 - ...codeExtendedEscapesInStrings16_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings16_ES6.types | 1 - ...eExtendedEscapesInStrings17_ES5.errors.txt | 7 +- .../unicodeExtendedEscapesInStrings17_ES5.js | 1 - ...eExtendedEscapesInStrings17_ES6.errors.txt | 7 +- .../unicodeExtendedEscapesInStrings17_ES6.js | 1 - .../unicodeExtendedEscapesInStrings18_ES5.js | 1 - ...codeExtendedEscapesInStrings18_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings18_ES5.types | 1 - .../unicodeExtendedEscapesInStrings18_ES6.js | 1 - ...codeExtendedEscapesInStrings18_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings18_ES6.types | 1 - ...eExtendedEscapesInStrings19_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings19_ES5.js | 1 - ...eExtendedEscapesInStrings19_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings19_ES6.js | 1 - ...eExtendedEscapesInStrings20_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings20_ES5.js | 1 - ...eExtendedEscapesInStrings20_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings20_ES6.js | 1 - ...eExtendedEscapesInStrings21_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings21_ES5.js | 1 - ...eExtendedEscapesInStrings21_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings21_ES6.js | 1 - ...eExtendedEscapesInStrings22_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings22_ES5.js | 1 - ...eExtendedEscapesInStrings22_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings22_ES6.js | 1 - .../unicodeExtendedEscapesInStrings23_ES5.js | 1 - ...codeExtendedEscapesInStrings23_ES5.symbols | 3 +- ...nicodeExtendedEscapesInStrings23_ES5.types | 1 - .../unicodeExtendedEscapesInStrings23_ES6.js | 1 - ...codeExtendedEscapesInStrings23_ES6.symbols | 3 +- ...nicodeExtendedEscapesInStrings23_ES6.types | 1 - ...eExtendedEscapesInStrings24_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings24_ES5.js | 1 - ...eExtendedEscapesInStrings24_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings24_ES6.js | 1 - ...eExtendedEscapesInStrings25_ES5.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings25_ES5.js | 1 - ...eExtendedEscapesInStrings25_ES6.errors.txt | 3 +- .../unicodeExtendedEscapesInStrings25_ES6.js | 1 - ...unicodeExtendedEscapesInTemplates01_ES5.js | 1 - ...deExtendedEscapesInTemplates01_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates01_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates01_ES6.js | 1 - ...deExtendedEscapesInTemplates01_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates01_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates02_ES5.js | 1 - ...deExtendedEscapesInTemplates02_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates02_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates02_ES6.js | 1 - ...deExtendedEscapesInTemplates02_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates02_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates03_ES5.js | 1 - ...deExtendedEscapesInTemplates03_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates03_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates03_ES6.js | 1 - ...deExtendedEscapesInTemplates03_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates03_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates04_ES5.js | 1 - ...deExtendedEscapesInTemplates04_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates04_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates04_ES6.js | 1 - ...deExtendedEscapesInTemplates04_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates04_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates05_ES5.js | 1 - ...deExtendedEscapesInTemplates05_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates05_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates05_ES6.js | 1 - ...deExtendedEscapesInTemplates05_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates05_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates06_ES5.js | 1 - ...deExtendedEscapesInTemplates06_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates06_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates06_ES6.js | 1 - ...deExtendedEscapesInTemplates06_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates06_ES6.types | 1 - ...xtendedEscapesInTemplates07_ES5.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates07_ES5.js | 1 - ...xtendedEscapesInTemplates07_ES6.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates07_ES6.js | 1 - ...unicodeExtendedEscapesInTemplates08_ES5.js | 1 - ...deExtendedEscapesInTemplates08_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates08_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates08_ES6.js | 1 - ...deExtendedEscapesInTemplates08_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates08_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates09_ES5.js | 1 - ...deExtendedEscapesInTemplates09_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates09_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates09_ES6.js | 1 - ...deExtendedEscapesInTemplates09_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates09_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates10_ES5.js | 1 - ...deExtendedEscapesInTemplates10_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates10_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates10_ES6.js | 1 - ...deExtendedEscapesInTemplates10_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates10_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates11_ES5.js | 1 - ...deExtendedEscapesInTemplates11_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates11_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates11_ES6.js | 1 - ...deExtendedEscapesInTemplates11_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates11_ES6.types | 1 - ...xtendedEscapesInTemplates12_ES5.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates12_ES5.js | 1 - ...xtendedEscapesInTemplates12_ES6.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates12_ES6.js | 1 - ...unicodeExtendedEscapesInTemplates13_ES5.js | 1 - ...deExtendedEscapesInTemplates13_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates13_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates13_ES6.js | 1 - ...deExtendedEscapesInTemplates13_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates13_ES6.types | 1 - ...xtendedEscapesInTemplates14_ES5.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates14_ES5.js | 1 - ...xtendedEscapesInTemplates14_ES6.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates14_ES6.js | 1 - ...unicodeExtendedEscapesInTemplates15_ES5.js | 1 - ...deExtendedEscapesInTemplates15_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates15_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates15_ES6.js | 1 - ...deExtendedEscapesInTemplates15_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates15_ES6.types | 1 - ...unicodeExtendedEscapesInTemplates16_ES5.js | 1 - ...deExtendedEscapesInTemplates16_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates16_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates16_ES6.js | 1 - ...deExtendedEscapesInTemplates16_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates16_ES6.types | 1 - ...xtendedEscapesInTemplates17_ES5.errors.txt | 7 +- ...unicodeExtendedEscapesInTemplates17_ES5.js | 1 - ...xtendedEscapesInTemplates17_ES6.errors.txt | 7 +- ...unicodeExtendedEscapesInTemplates17_ES6.js | 1 - ...unicodeExtendedEscapesInTemplates18_ES5.js | 1 - ...deExtendedEscapesInTemplates18_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates18_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates18_ES6.js | 1 - ...deExtendedEscapesInTemplates18_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates18_ES6.types | 1 - ...xtendedEscapesInTemplates19_ES5.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates19_ES5.js | 1 - ...xtendedEscapesInTemplates19_ES6.errors.txt | 3 +- ...unicodeExtendedEscapesInTemplates19_ES6.js | 1 - ...unicodeExtendedEscapesInTemplates20_ES5.js | 1 - ...deExtendedEscapesInTemplates20_ES5.symbols | 3 +- ...codeExtendedEscapesInTemplates20_ES5.types | 1 - ...unicodeExtendedEscapesInTemplates20_ES6.js | 1 - ...deExtendedEscapesInTemplates20_ES6.symbols | 3 +- ...codeExtendedEscapesInTemplates20_ES6.types | 1 - .../reference/unreachableFlowAfterFinally.js | 1 - .../unreachableFlowAfterFinally.symbols | 7 +- .../unreachableFlowAfterFinally.types | 1 - .../unusedClassesinModule1.errors.txt | 3 +- .../reference/unusedClassesinModule1.js | 1 - .../unusedClassesinNamespace1.errors.txt | 3 +- .../reference/unusedClassesinNamespace1.js | 1 - .../unusedClassesinNamespace2.errors.txt | 3 +- .../reference/unusedClassesinNamespace2.js | 1 - .../reference/unusedClassesinNamespace3.js | 1 - .../unusedClassesinNamespace3.symbols | 9 +- .../reference/unusedClassesinNamespace3.types | 1 - .../unusedClassesinNamespace4.errors.txt | 3 +- .../reference/unusedClassesinNamespace4.js | 1 - .../unusedClassesinNamespace5.errors.txt | 3 +- .../reference/unusedClassesinNamespace5.js | 1 - .../unusedFunctionsinNamespaces1.errors.txt | 3 +- .../reference/unusedFunctionsinNamespaces1.js | 1 - .../unusedFunctionsinNamespaces2.errors.txt | 3 +- .../reference/unusedFunctionsinNamespaces2.js | 1 - .../unusedFunctionsinNamespaces3.errors.txt | 5 +- .../reference/unusedFunctionsinNamespaces3.js | 1 - .../unusedFunctionsinNamespaces4.errors.txt | 3 +- .../reference/unusedFunctionsinNamespaces4.js | 1 - .../unusedFunctionsinNamespaces5.errors.txt | 5 +- .../reference/unusedFunctionsinNamespaces5.js | 1 - .../unusedFunctionsinNamespaces6.errors.txt | 3 +- .../reference/unusedFunctionsinNamespaces6.js | 1 - .../reference/unusedGetterInClass.js | 1 - .../reference/unusedGetterInClass.symbols | 9 +- .../reference/unusedGetterInClass.types | 1 - .../unusedIdentifiersConsolidated1.errors.txt | 33 +- .../unusedIdentifiersConsolidated1.js | 1 - .../reference/unusedImports1.errors.txt | 1 - tests/baselines/reference/unusedImports1.js | 1 - .../reference/unusedImports10.errors.txt | 3 +- tests/baselines/reference/unusedImports10.js | 1 - tests/baselines/reference/unusedImports11.js | 1 - .../reference/unusedImports11.symbols | 1 - .../baselines/reference/unusedImports11.types | 1 - .../reference/unusedImports12.errors.txt | 1 - tests/baselines/reference/unusedImports12.js | 1 - tests/baselines/reference/unusedImports13.js | 1 - .../reference/unusedImports13.symbols | 3 +- .../baselines/reference/unusedImports13.types | 1 - tests/baselines/reference/unusedImports14.js | 1 - .../reference/unusedImports14.symbols | 3 +- .../baselines/reference/unusedImports14.types | 1 - tests/baselines/reference/unusedImports15.js | 1 - .../reference/unusedImports15.symbols | 3 +- .../baselines/reference/unusedImports15.types | 1 - tests/baselines/reference/unusedImports16.js | 1 - .../reference/unusedImports16.symbols | 3 +- .../baselines/reference/unusedImports16.types | 1 - .../reference/unusedImports2.errors.txt | 1 - tests/baselines/reference/unusedImports2.js | 1 - .../reference/unusedImports3.errors.txt | 1 - tests/baselines/reference/unusedImports3.js | 1 - .../reference/unusedImports4.errors.txt | 1 - tests/baselines/reference/unusedImports4.js | 1 - .../reference/unusedImports5.errors.txt | 1 - tests/baselines/reference/unusedImports5.js | 1 - .../reference/unusedImports6.errors.txt | 1 - tests/baselines/reference/unusedImports6.js | 1 - .../reference/unusedImports7.errors.txt | 1 - tests/baselines/reference/unusedImports7.js | 1 - .../reference/unusedImports8.errors.txt | 1 - tests/baselines/reference/unusedImports8.js | 1 - .../reference/unusedImports9.errors.txt | 1 - tests/baselines/reference/unusedImports9.js | 1 - .../unusedInterfaceinNamespace1.errors.txt | 3 +- .../reference/unusedInterfaceinNamespace1.js | 1 - .../unusedInterfaceinNamespace2.errors.txt | 3 +- .../reference/unusedInterfaceinNamespace2.js | 1 - .../unusedInterfaceinNamespace3.errors.txt | 3 +- .../reference/unusedInterfaceinNamespace3.js | 1 - .../reference/unusedInterfaceinNamespace4.js | 1 - .../unusedInterfaceinNamespace4.symbols | 13 +- .../unusedInterfaceinNamespace4.types | 1 - .../reference/unusedInterfaceinNamespace5.js | 1 - .../unusedInterfaceinNamespace5.symbols | 19 +- .../unusedInterfaceinNamespace5.types | 1 - .../unusedLocalsAndObjectSpread.errors.txt | 5 +- .../reference/unusedLocalsAndObjectSpread.js | 1 - .../unusedLocalsAndObjectSpread2.errors.txt | 7 +- .../reference/unusedLocalsAndObjectSpread2.js | 1 - .../unusedLocalsAndParameters.errors.txt | 49 +- .../reference/unusedLocalsAndParameters.js | 1 - ...usedLocalsAndParametersDeferred.errors.txt | 7 +- .../unusedLocalsAndParametersDeferred.js | 1 - ...edLocalsAndParametersOverloadSignatures.js | 1 - ...alsAndParametersOverloadSignatures.symbols | 75 +- ...ocalsAndParametersOverloadSignatures.types | 1 - .../unusedLocalsAndParametersTypeAliases.js | 1 - ...usedLocalsAndParametersTypeAliases.symbols | 39 +- ...unusedLocalsAndParametersTypeAliases.types | 1 - ...LocalsAndParametersTypeAliases2.errors.txt | 5 +- .../unusedLocalsAndParametersTypeAliases2.js | 1 - .../unusedLocalsInMethod1.errors.txt | 3 +- .../reference/unusedLocalsInMethod1.js | 1 - .../unusedLocalsInMethod2.errors.txt | 3 +- .../reference/unusedLocalsInMethod2.js | 1 - .../unusedLocalsInMethod3.errors.txt | 3 +- .../reference/unusedLocalsInMethod3.js | 1 - ...ationWithinFunctionDeclaration1.errors.txt | 11 +- ...onDeclarationWithinFunctionDeclaration1.js | 1 - ...ationWithinFunctionDeclaration2.errors.txt | 15 +- ...onDeclarationWithinFunctionDeclaration2.js | 1 - ...rationWithinFunctionExpression1.errors.txt | 11 +- ...ionDeclarationWithinFunctionExpression1.js | 1 - ...rationWithinFunctionExpression2.errors.txt | 15 +- ...ionDeclarationWithinFunctionExpression2.js | 1 - ...ssionWithinFunctionDeclaration1.errors.txt | 11 +- ...ionExpressionWithinFunctionDeclaration1.js | 1 - ...ssionWithinFunctionDeclaration2.errors.txt | 15 +- ...ionExpressionWithinFunctionDeclaration2.js | 1 - ...essionWithinFunctionExpression1.errors.txt | 11 +- ...tionExpressionWithinFunctionExpression1.js | 1 - ...essionWithinFunctionExpression2.errors.txt | 15 +- ...tionExpressionWithinFunctionExpression2.js | 1 - ...sedLocalsStartingWithUnderscore.errors.txt | 3 +- .../unusedLocalsStartingWithUnderscore.js | 1 - .../unusedLocalsinConstructor1.errors.txt | 3 +- .../reference/unusedLocalsinConstructor1.js | 1 - .../unusedLocalsinConstructor2.errors.txt | 3 +- .../reference/unusedLocalsinConstructor2.js | 1 - .../reference/unusedMethodsInInterface.js | 1 - .../unusedMethodsInInterface.symbols | 9 +- .../reference/unusedMethodsInInterface.types | 1 - .../reference/unusedModuleInModule.errors.txt | 3 +- .../reference/unusedModuleInModule.js | 1 - ...dMultipleParameter1InContructor.errors.txt | 5 +- .../unusedMultipleParameter1InContructor.js | 1 - ...eParameter1InFunctionExpression.errors.txt | 5 +- ...dMultipleParameter1InFunctionExpression.js | 1 - ...dMultipleParameter2InContructor.errors.txt | 7 +- .../unusedMultipleParameter2InContructor.js | 1 - ...eParameter2InFunctionExpression.errors.txt | 7 +- ...dMultipleParameter2InFunctionExpression.js | 1 - ...arameters1InFunctionDeclaration.errors.txt | 5 +- ...ultipleParameters1InFunctionDeclaration.js | 1 - ...eParameters1InMethodDeclaration.errors.txt | 5 +- ...dMultipleParameters1InMethodDeclaration.js | 1 - ...arameters2InFunctionDeclaration.errors.txt | 7 +- ...ultipleParameters2InFunctionDeclaration.js | 1 - ...eParameters2InMethodDeclaration.errors.txt | 7 +- ...dMultipleParameters2InMethodDeclaration.js | 1 - .../unusedNamespaceInModule.errors.txt | 3 +- .../reference/unusedNamespaceInModule.js | 1 - .../unusedNamespaceInNamespace.errors.txt | 3 +- .../reference/unusedNamespaceInNamespace.js | 1 - .../reference/unusedParameterInCatchClause.js | 1 - .../unusedParameterInCatchClause.symbols | 3 +- .../unusedParameterInCatchClause.types | 1 - .../unusedParameterProperty1.errors.txt | 3 +- .../reference/unusedParameterProperty1.js | 1 - .../unusedParameterProperty2.errors.txt | 3 +- .../reference/unusedParameterProperty2.js | 1 - .../reference/unusedParameterUsedInTypeOf.js | 1 - .../unusedParameterUsedInTypeOf.symbols | 9 +- .../unusedParameterUsedInTypeOf.types | 1 - .../unusedParametersInLambda1.errors.txt | 3 +- .../reference/unusedParametersInLambda1.js | 1 - .../unusedParametersInLambda2.errors.txt | 3 +- .../reference/unusedParametersInLambda2.js | 1 - .../reference/unusedParametersThis.js | 1 - .../reference/unusedParametersThis.symbols | 83 +- .../reference/unusedParametersThis.types | 1 - .../unusedParametersWithUnderscore.errors.txt | 13 +- .../unusedParametersWithUnderscore.js | 1 - .../unusedParametersinConstructor1.errors.txt | 3 +- .../unusedParametersinConstructor1.js | 1 - .../unusedParametersinConstructor2.errors.txt | 3 +- .../unusedParametersinConstructor2.js | 1 - .../unusedParametersinConstructor3.errors.txt | 5 +- .../unusedParametersinConstructor3.js | 1 - .../reference/unusedPrivateMembers.js | 1 - .../reference/unusedPrivateMembers.symbols | 85 +- .../reference/unusedPrivateMembers.types | 1 - .../unusedPrivateMethodInClass1.errors.txt | 3 +- .../reference/unusedPrivateMethodInClass1.js | 1 - .../unusedPrivateMethodInClass2.errors.txt | 5 +- .../reference/unusedPrivateMethodInClass2.js | 1 - .../unusedPrivateMethodInClass3.errors.txt | 5 +- .../reference/unusedPrivateMethodInClass3.js | 1 - .../unusedPrivateMethodInClass4.errors.txt | 3 +- .../reference/unusedPrivateMethodInClass4.js | 1 - .../unusedPrivateVariableInClass1.errors.txt | 3 +- .../unusedPrivateVariableInClass1.js | 1 - .../unusedPrivateVariableInClass2.errors.txt | 5 +- .../unusedPrivateVariableInClass2.js | 1 - .../unusedPrivateVariableInClass3.errors.txt | 5 +- .../unusedPrivateVariableInClass3.js | 1 - .../unusedPrivateVariableInClass4.errors.txt | 3 +- .../unusedPrivateVariableInClass4.js | 1 - .../unusedPrivateVariableInClass5.errors.txt | 3 +- .../unusedPrivateVariableInClass5.js | 1 - .../reference/unusedSetterInClass.js | 1 - .../reference/unusedSetterInClass.symbols | 13 +- .../reference/unusedSetterInClass.types | 1 - ...usedSingleParameterInContructor.errors.txt | 5 +- .../unusedSingleParameterInContructor.js | 1 - ...eParameterInFunctionDeclaration.errors.txt | 5 +- ...sedSingleParameterInFunctionDeclaration.js | 1 - ...leParameterInFunctionExpression.errors.txt | 5 +- ...usedSingleParameterInFunctionExpression.js | 1 - ...gleParameterInMethodDeclaration.errors.txt | 5 +- ...nusedSingleParameterInMethodDeclaration.js | 1 - .../reference/unusedSwitchStatment.errors.txt | 13 +- .../reference/unusedSwitchStatment.js | 1 - .../unusedTypeParameterInFunction1.errors.txt | 3 +- .../unusedTypeParameterInFunction1.js | 1 - .../unusedTypeParameterInFunction2.errors.txt | 3 +- .../unusedTypeParameterInFunction2.js | 1 - .../unusedTypeParameterInFunction3.errors.txt | 3 +- .../unusedTypeParameterInFunction3.js | 1 - .../unusedTypeParameterInFunction4.errors.txt | 3 +- .../unusedTypeParameterInFunction4.js | 1 - ...unusedTypeParameterInInterface1.errors.txt | 3 +- .../unusedTypeParameterInInterface1.js | 1 - ...unusedTypeParameterInInterface2.errors.txt | 3 +- .../unusedTypeParameterInInterface2.js | 1 - .../unusedTypeParameterInLambda1.errors.txt | 3 +- .../reference/unusedTypeParameterInLambda1.js | 1 - .../unusedTypeParameterInLambda2.errors.txt | 3 +- .../reference/unusedTypeParameterInLambda2.js | 1 - .../unusedTypeParameterInMethod1.errors.txt | 3 +- .../reference/unusedTypeParameterInMethod1.js | 1 - .../unusedTypeParameterInMethod2.errors.txt | 3 +- .../reference/unusedTypeParameterInMethod2.js | 1 - .../unusedTypeParameterInMethod3.errors.txt | 3 +- .../reference/unusedTypeParameterInMethod3.js | 1 - .../unusedTypeParameterInMethod4.errors.txt | 3 +- .../reference/unusedTypeParameterInMethod4.js | 1 - .../unusedTypeParameterInMethod5.errors.txt | 3 +- .../reference/unusedTypeParameterInMethod5.js | 1 - .../unusedTypeParameters1.errors.txt | 3 +- .../reference/unusedTypeParameters1.js | 1 - .../unusedTypeParameters2.errors.txt | 3 +- .../reference/unusedTypeParameters2.js | 1 - .../unusedTypeParameters3.errors.txt | 5 +- .../reference/unusedTypeParameters3.js | 1 - .../unusedTypeParameters4.errors.txt | 3 +- .../reference/unusedTypeParameters4.js | 1 - .../unusedTypeParameters5.errors.txt | 3 +- .../reference/unusedTypeParameters5.js | 1 - .../reference/unusedTypeParameters6.js | 1 - .../reference/unusedTypeParameters6.symbols | 7 +- .../reference/unusedTypeParameters6.types | 1 - .../reference/unusedTypeParameters7.js | 1 - .../reference/unusedTypeParameters7.symbols | 9 +- .../reference/unusedTypeParameters7.types | 1 - .../unusedTypeParameters8.errors.txt | 1 - .../reference/unusedTypeParameters8.js | 1 - .../reference/unusedTypeParameters9.js | 1 - .../reference/unusedTypeParameters9.symbols | 61 +- .../reference/unusedTypeParameters9.types | 1 - .../unusedVariablesinBlocks1.errors.txt | 3 +- .../reference/unusedVariablesinBlocks1.js | 1 - .../unusedVariablesinBlocks2.errors.txt | 3 +- .../reference/unusedVariablesinBlocks2.js | 1 - .../unusedVariablesinForLoop.errors.txt | 3 +- .../reference/unusedVariablesinForLoop.js | 1 - .../unusedVariablesinForLoop2.errors.txt | 3 +- .../reference/unusedVariablesinForLoop2.js | 1 - .../unusedVariablesinForLoop3.errors.txt | 3 +- .../reference/unusedVariablesinForLoop3.js | 1 - .../unusedVariablesinForLoop4.errors.txt | 3 +- .../reference/unusedVariablesinForLoop4.js | 1 - .../unusedVariablesinModules1.errors.txt | 3 +- .../reference/unusedVariablesinModules1.js | 1 - .../unusedVariablesinNamespaces1.errors.txt | 3 +- .../reference/unusedVariablesinNamespaces1.js | 1 - .../unusedVariablesinNamespaces2.errors.txt | 3 +- .../reference/unusedVariablesinNamespaces2.js | 1 - .../unusedVariablesinNamespaces3.errors.txt | 3 +- .../reference/unusedVariablesinNamespaces3.js | 1 - .../reference/useBeforeDeclaration.js | 1 - .../reference/useBeforeDeclaration.symbols | 9 +- .../reference/useBeforeDeclaration.types | 1 - .../reference/useObjectValuesAndEntries1.js | 1 - .../useObjectValuesAndEntries1.symbols | 29 +- .../useObjectValuesAndEntries1.types | 1 - .../useObjectValuesAndEntries2.errors.txt | 5 +- .../reference/useObjectValuesAndEntries2.js | 1 - .../useObjectValuesAndEntries3.errors.txt | 5 +- .../reference/useObjectValuesAndEntries3.js | 1 - .../reference/useObjectValuesAndEntries4.js | 1 - .../useObjectValuesAndEntries4.symbols | 19 +- .../useObjectValuesAndEntries4.types | 1 - .../reference/useSharedArrayBuffer1.js | 1 - .../reference/useSharedArrayBuffer1.symbols | 11 +- .../reference/useSharedArrayBuffer1.types | 1 - .../useSharedArrayBuffer2.errors.txt | 3 +- .../reference/useSharedArrayBuffer2.js | 1 - .../useSharedArrayBuffer3.errors.txt | 3 +- .../reference/useSharedArrayBuffer3.js | 1 - .../reference/useSharedArrayBuffer4.js | 1 - .../reference/useSharedArrayBuffer4.symbols | 19 +- .../reference/useSharedArrayBuffer4.types | 1 - .../reference/useSharedArrayBuffer5.js | 1 - .../reference/useSharedArrayBuffer5.symbols | 11 +- .../reference/useSharedArrayBuffer5.types | 1 - .../reference/useSharedArrayBuffer6.js | 1 - .../reference/useSharedArrayBuffer6.symbols | 11 +- .../reference/useSharedArrayBuffer6.types | 1 - .../useStrictLikePrologueString01.js | 1 - .../useStrictLikePrologueString01.symbols | 3 +- .../useStrictLikePrologueString01.types | 1 - tests/baselines/reference/varAsID.js | 1 - tests/baselines/reference/varAsID.symbols | 17 +- tests/baselines/reference/varAsID.types | 1 - .../reference/verifyDefaultLib_dom.js | 1 - .../reference/verifyDefaultLib_dom.symbols | 3 +- .../reference/verifyDefaultLib_dom.types | 1 - .../reference/verifyDefaultLib_webworker.js | 1 - .../verifyDefaultLib_webworker.symbols | 3 +- .../verifyDefaultLib_webworker.types | 1 - .../reference/visibilityOfTypeParameters.js | 1 - .../visibilityOfTypeParameters.symbols | 13 +- .../visibilityOfTypeParameters.types | 1 - .../reference/whileBreakStatements.js | 1 - .../reference/whileBreakStatements.symbols | 3 +- .../reference/whileBreakStatements.types | 1 - .../reference/widenToAny1.errors.txt | 3 +- tests/baselines/reference/widenToAny1.js | 1 - .../reference/widenedTypes.errors.txt | 19 +- tests/baselines/reference/widenedTypes.js | 1 - tests/baselines/reference/witness.errors.txt | 30 +- tests/baselines/reference/witness.js | 4 - .../cases/compiler/emitBundleWithShebang1.ts | 7 + .../cases/compiler/emitBundleWithShebang2.ts | 13 + 4746 files changed, 25195 insertions(+), 30008 deletions(-) create mode 100644 tests/baselines/reference/emitBundleWithShebang1.js create mode 100644 tests/baselines/reference/emitBundleWithShebang1.symbols create mode 100644 tests/baselines/reference/emitBundleWithShebang1.types create mode 100644 tests/baselines/reference/emitBundleWithShebang2.js create mode 100644 tests/baselines/reference/emitBundleWithShebang2.symbols create mode 100644 tests/baselines/reference/emitBundleWithShebang2.types create mode 100644 tests/cases/compiler/emitBundleWithShebang1.ts create mode 100644 tests/cases/compiler/emitBundleWithShebang2.ts diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 8935da642d4..a20c6229f54 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -1885,7 +1885,7 @@ namespace Harness { if (currentFileContent === undefined) { currentFileContent = ""; } - else { + else if (currentFileContent !== "") { // End-of-line currentFileContent = currentFileContent + "\n"; } diff --git a/tests/baselines/reference/APISample_compile.js b/tests/baselines/reference/APISample_compile.js index 0315fd516b5..b7b55900281 100644 --- a/tests/baselines/reference/APISample_compile.js +++ b/tests/baselines/reference/APISample_compile.js @@ -1,5 +1,4 @@ //// [APISample_compile.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index 57ebd64c4e2..02676c467bd 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -1,5 +1,4 @@ //// [APISample_linter.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter diff --git a/tests/baselines/reference/APISample_parseConfig.js b/tests/baselines/reference/APISample_parseConfig.js index 77f0a07c1df..009ed4b6a37 100644 --- a/tests/baselines/reference/APISample_parseConfig.js +++ b/tests/baselines/reference/APISample_parseConfig.js @@ -1,5 +1,4 @@ //// [APISample_parseConfig.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler diff --git a/tests/baselines/reference/APISample_transform.js b/tests/baselines/reference/APISample_transform.js index 0716e59edb7..58590f8c711 100644 --- a/tests/baselines/reference/APISample_transform.js +++ b/tests/baselines/reference/APISample_transform.js @@ -1,5 +1,4 @@ //// [APISample_transform.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-simple-transform-function diff --git a/tests/baselines/reference/APISample_watcher.js b/tests/baselines/reference/APISample_watcher.js index f4400ccda4c..e9ca423b9fa 100644 --- a/tests/baselines/reference/APISample_watcher.js +++ b/tests/baselines/reference/APISample_watcher.js @@ -1,5 +1,4 @@ //// [APISample_watcher.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#incremental-build-support-using-the-language-services diff --git a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt index 1f442e98d12..0a8f03a504a 100644 --- a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt +++ b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts(4,8): error TS4033: Property 'f' of exported interface has or is using private name 'T'. +tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts(3,8): error TS4033: Property 'f' of exported interface has or is using private name 'T'. ==== tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts (1 errors) ==== - type T = { x : number } export interface I { f: T; diff --git a/tests/baselines/reference/ES5for-of32.js b/tests/baselines/reference/ES5for-of32.js index 7af7cc3874a..747f9524062 100644 --- a/tests/baselines/reference/ES5for-of32.js +++ b/tests/baselines/reference/ES5for-of32.js @@ -1,5 +1,4 @@ //// [ES5for-of32.ts] - var array = [1,2,3]; var sum = 0; diff --git a/tests/baselines/reference/ES5for-of32.symbols b/tests/baselines/reference/ES5for-of32.symbols index 5672ad01109..b6fa8810382 100644 --- a/tests/baselines/reference/ES5for-of32.symbols +++ b/tests/baselines/reference/ES5for-of32.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts === - var array = [1,2,3]; ->array : Symbol(array, Decl(ES5for-of32.ts, 1, 3)) +>array : Symbol(array, Decl(ES5for-of32.ts, 0, 3)) var sum = 0; ->sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3)) +>sum : Symbol(sum, Decl(ES5for-of32.ts, 1, 3)) for (let num of array) { ->num : Symbol(num, Decl(ES5for-of32.ts, 4, 8)) ->array : Symbol(array, Decl(ES5for-of32.ts, 1, 3)) +>num : Symbol(num, Decl(ES5for-of32.ts, 3, 8)) +>array : Symbol(array, Decl(ES5for-of32.ts, 0, 3)) if (sum === 0) { ->sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3)) +>sum : Symbol(sum, Decl(ES5for-of32.ts, 1, 3)) array = [4,5,6] ->array : Symbol(array, Decl(ES5for-of32.ts, 1, 3)) +>array : Symbol(array, Decl(ES5for-of32.ts, 0, 3)) } sum += num; ->sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3)) ->num : Symbol(num, Decl(ES5for-of32.ts, 4, 8)) +>sum : Symbol(sum, Decl(ES5for-of32.ts, 1, 3)) +>num : Symbol(num, Decl(ES5for-of32.ts, 3, 8)) } diff --git a/tests/baselines/reference/ES5for-of32.types b/tests/baselines/reference/ES5for-of32.types index 188500c4859..22e387d8484 100644 --- a/tests/baselines/reference/ES5for-of32.types +++ b/tests/baselines/reference/ES5for-of32.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts === - var array = [1,2,3]; >array : number[] >[1,2,3] : number[] diff --git a/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt b/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt index a7b6b5de43d..b6d4c4c6990 100644 --- a/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt +++ b/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(3,8): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(4,5): error TS2304: Cannot find name 'let'. -tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(5,10): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(2,8): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(3,5): error TS2304: Cannot find name 'let'. +tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(4,10): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts (3 errors) ==== - module Inner { var; diff --git a/tests/baselines/reference/NonInitializedExportInInternalModule.js b/tests/baselines/reference/NonInitializedExportInInternalModule.js index aa1c84664ad..129dd104282 100644 --- a/tests/baselines/reference/NonInitializedExportInInternalModule.js +++ b/tests/baselines/reference/NonInitializedExportInInternalModule.js @@ -1,5 +1,4 @@ //// [NonInitializedExportInInternalModule.ts] - module Inner { var; let; diff --git a/tests/baselines/reference/VariableDeclaration12_es6.js b/tests/baselines/reference/VariableDeclaration12_es6.js index 1e7d6d4b363..da0748d2191 100644 --- a/tests/baselines/reference/VariableDeclaration12_es6.js +++ b/tests/baselines/reference/VariableDeclaration12_es6.js @@ -1,5 +1,4 @@ //// [VariableDeclaration12_es6.ts] - let x diff --git a/tests/baselines/reference/VariableDeclaration12_es6.symbols b/tests/baselines/reference/VariableDeclaration12_es6.symbols index a2f324502dd..5c4f583fbb2 100644 --- a/tests/baselines/reference/VariableDeclaration12_es6.symbols +++ b/tests/baselines/reference/VariableDeclaration12_es6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration12_es6.ts === - let x ->x : Symbol(x, Decl(VariableDeclaration12_es6.ts, 1, 3)) +>x : Symbol(x, Decl(VariableDeclaration12_es6.ts, 0, 3)) diff --git a/tests/baselines/reference/VariableDeclaration12_es6.types b/tests/baselines/reference/VariableDeclaration12_es6.types index 14f23f88a7a..db8acdffd79 100644 --- a/tests/baselines/reference/VariableDeclaration12_es6.types +++ b/tests/baselines/reference/VariableDeclaration12_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration12_es6.ts === - let x >x : any diff --git a/tests/baselines/reference/VariableDeclaration13_es6.errors.txt b/tests/baselines/reference/VariableDeclaration13_es6.errors.txt index a022a4ad52b..1780e06e2af 100644 --- a/tests/baselines/reference/VariableDeclaration13_es6.errors.txt +++ b/tests/baselines/reference/VariableDeclaration13_es6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,5): error TS1181: Array element destructuring pattern expected. -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,6): error TS1005: ',' expected. -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,8): error TS1134: Variable declaration expected. -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,10): error TS1134: Variable declaration expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,5): error TS1181: Array element destructuring pattern expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,6): error TS1005: ',' expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,8): error TS1134: Variable declaration expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,10): error TS1134: Variable declaration expected. ==== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts (4 errors) ==== - // An ExpressionStatement cannot start with the two token sequence `let [` because // that would make it ambiguous with a `let` LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern. var let: any; diff --git a/tests/baselines/reference/VariableDeclaration13_es6.js b/tests/baselines/reference/VariableDeclaration13_es6.js index 4ec04b18c3a..1acd0fdbe02 100644 --- a/tests/baselines/reference/VariableDeclaration13_es6.js +++ b/tests/baselines/reference/VariableDeclaration13_es6.js @@ -1,5 +1,4 @@ //// [VariableDeclaration13_es6.ts] - // An ExpressionStatement cannot start with the two token sequence `let [` because // that would make it ambiguous with a `let` LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern. var let: any; diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.js b/tests/baselines/reference/abstractInterfaceIdentifierName.js index 67058bfc619..1e60d065dbc 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.js +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.js @@ -1,5 +1,4 @@ //// [abstractInterfaceIdentifierName.ts] - interface abstract { abstract(): void; } diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols index 29a1a361894..9b8192db1d3 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/abstractInterfaceIdentifierName.ts === - interface abstract { >abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 0)) abstract(): void; ->abstract : Symbol(abstract.abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20)) +>abstract : Symbol(abstract.abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 20)) } diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.types b/tests/baselines/reference/abstractInterfaceIdentifierName.types index c6d30ca38a0..2aba754cfa0 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.types +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.types @@ -1,5 +1,4 @@ === tests/cases/compiler/abstractInterfaceIdentifierName.ts === - interface abstract { >abstract : abstract diff --git a/tests/baselines/reference/accessibilityModifiers.errors.txt b/tests/baselines/reference/accessibilityModifiers.errors.txt index 1bf92139761..7d4351bd7b6 100644 --- a/tests/baselines/reference/accessibilityModifiers.errors.txt +++ b/tests/baselines/reference/accessibilityModifiers.errors.txt @@ -1,23 +1,22 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(21,12): error TS1029: 'private' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(22,12): error TS1029: 'private' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(23,12): error TS1029: 'private' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(24,12): error TS1029: 'private' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(25,12): error TS1029: 'private' modifier must precede 'static' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(26,12): error TS1029: 'protected' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(27,12): error TS1029: 'protected' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(28,12): error TS1029: 'protected' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(29,12): error TS1029: 'protected' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(30,12): error TS1029: 'protected' modifier must precede 'static' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(31,12): error TS1029: 'public' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(32,12): error TS1029: 'public' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(33,12): error TS1029: 'public' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(34,12): error TS1029: 'public' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(35,12): error TS1029: 'public' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(40,13): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(41,12): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(42,13): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(43,12): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(39,13): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(40,12): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(41,13): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(42,12): error TS1028: Accessibility modifier already seen. ==== tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts (16 errors) ==== - // No errors class C { private static privateProperty; diff --git a/tests/baselines/reference/accessibilityModifiers.js b/tests/baselines/reference/accessibilityModifiers.js index c50092d1459..ef092976ba8 100644 --- a/tests/baselines/reference/accessibilityModifiers.js +++ b/tests/baselines/reference/accessibilityModifiers.js @@ -1,5 +1,4 @@ //// [accessibilityModifiers.ts] - // No errors class C { private static privateProperty; diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt b/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt index 3036e734105..17216739372 100644 --- a/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt +++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorParameterAccessibilityModifier.ts(3,11): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/accessorParameterAccessibilityModifier.ts(4,18): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/accessorParameterAccessibilityModifier.ts(2,11): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/accessorParameterAccessibilityModifier.ts(3,18): error TS2369: A parameter property is only allowed in a constructor implementation. ==== tests/cases/compiler/accessorParameterAccessibilityModifier.ts (2 errors) ==== - class C { set X(public v) { } ~~~~~~~~ diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.js b/tests/baselines/reference/accessorParameterAccessibilityModifier.js index 4aa8451feed..b0667ddc726 100644 --- a/tests/baselines/reference/accessorParameterAccessibilityModifier.js +++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.js @@ -1,5 +1,4 @@ //// [accessorParameterAccessibilityModifier.ts] - class C { set X(public v) { } static set X(public v2) { } diff --git a/tests/baselines/reference/accessorWithES3.errors.txt b/tests/baselines/reference/accessorWithES3.errors.txt index 0b4510a12ca..0a2219d85a4 100644 --- a/tests/baselines/reference/accessorWithES3.errors.txt +++ b/tests/baselines/reference/accessorWithES3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(5,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(11,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(16,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(20,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(4,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(10,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(15,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(19,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts (4 errors) ==== - // error to use accessors in ES3 mode class C { diff --git a/tests/baselines/reference/accessorWithES3.js b/tests/baselines/reference/accessorWithES3.js index 6384712fc9d..84ea2195478 100644 --- a/tests/baselines/reference/accessorWithES3.js +++ b/tests/baselines/reference/accessorWithES3.js @@ -1,5 +1,4 @@ //// [accessorWithES3.ts] - // error to use accessors in ES3 mode class C { diff --git a/tests/baselines/reference/accessorWithES5.js b/tests/baselines/reference/accessorWithES5.js index 3a94de76988..549ecd25e65 100644 --- a/tests/baselines/reference/accessorWithES5.js +++ b/tests/baselines/reference/accessorWithES5.js @@ -1,5 +1,4 @@ //// [accessorWithES5.ts] - class C { get x() { return 1; diff --git a/tests/baselines/reference/accessorWithES5.symbols b/tests/baselines/reference/accessorWithES5.symbols index 46e8d6f91da..1a0d8ee70ea 100644 --- a/tests/baselines/reference/accessorWithES5.symbols +++ b/tests/baselines/reference/accessorWithES5.symbols @@ -1,35 +1,34 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts === - class C { >C : Symbol(C, Decl(accessorWithES5.ts, 0, 0)) get x() { ->x : Symbol(C.x, Decl(accessorWithES5.ts, 1, 9)) +>x : Symbol(C.x, Decl(accessorWithES5.ts, 0, 9)) return 1; } } class D { ->D : Symbol(D, Decl(accessorWithES5.ts, 5, 1)) +>D : Symbol(D, Decl(accessorWithES5.ts, 4, 1)) set x(v) { ->x : Symbol(D.x, Decl(accessorWithES5.ts, 7, 9)) ->v : Symbol(v, Decl(accessorWithES5.ts, 8, 10)) +>x : Symbol(D.x, Decl(accessorWithES5.ts, 6, 9)) +>v : Symbol(v, Decl(accessorWithES5.ts, 7, 10)) } } var x = { ->x : Symbol(x, Decl(accessorWithES5.ts, 12, 3)) +>x : Symbol(x, Decl(accessorWithES5.ts, 11, 3)) get a() { return 1 } ->a : Symbol(a, Decl(accessorWithES5.ts, 12, 9)) +>a : Symbol(a, Decl(accessorWithES5.ts, 11, 9)) } var y = { ->y : Symbol(y, Decl(accessorWithES5.ts, 16, 3)) +>y : Symbol(y, Decl(accessorWithES5.ts, 15, 3)) set b(v) { } ->b : Symbol(b, Decl(accessorWithES5.ts, 16, 9)) ->v : Symbol(v, Decl(accessorWithES5.ts, 17, 10)) +>b : Symbol(b, Decl(accessorWithES5.ts, 15, 9)) +>v : Symbol(v, Decl(accessorWithES5.ts, 16, 10)) } diff --git a/tests/baselines/reference/accessorWithES5.types b/tests/baselines/reference/accessorWithES5.types index 4d23f61c0eb..604f7c4301b 100644 --- a/tests/baselines/reference/accessorWithES5.types +++ b/tests/baselines/reference/accessorWithES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts === - class C { >C : C diff --git a/tests/baselines/reference/accessorWithInitializer.errors.txt b/tests/baselines/reference/accessorWithInitializer.errors.txt index 338d9559e4c..1e64be49a1e 100644 --- a/tests/baselines/reference/accessorWithInitializer.errors.txt +++ b/tests/baselines/reference/accessorWithInitializer.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorWithInitializer.ts(3,9): error TS1052: A 'set' accessor parameter cannot have an initializer. -tests/cases/compiler/accessorWithInitializer.ts(4,16): error TS1052: A 'set' accessor parameter cannot have an initializer. +tests/cases/compiler/accessorWithInitializer.ts(2,9): error TS1052: A 'set' accessor parameter cannot have an initializer. +tests/cases/compiler/accessorWithInitializer.ts(3,16): error TS1052: A 'set' accessor parameter cannot have an initializer. ==== tests/cases/compiler/accessorWithInitializer.ts (2 errors) ==== - class C { set X(v = 0) { } ~ diff --git a/tests/baselines/reference/accessorWithInitializer.js b/tests/baselines/reference/accessorWithInitializer.js index d4562e635dc..2d2e03a05da 100644 --- a/tests/baselines/reference/accessorWithInitializer.js +++ b/tests/baselines/reference/accessorWithInitializer.js @@ -1,5 +1,4 @@ //// [accessorWithInitializer.ts] - class C { set X(v = 0) { } static set X(v2 = 0) { } diff --git a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt index 6c12df93dd1..9d1b7ca9a30 100644 --- a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt +++ b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(3,9): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(6,17): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(11,19): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(14,17): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(19,19): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(21,9): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(27,26): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(29,16): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(2,9): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(5,17): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(10,19): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(13,17): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(18,19): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(20,9): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(26,26): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(28,16): error TS2379: Getter and setter accessors do not agree in visibility. ==== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts (8 errors) ==== - class C { get x() { ~ diff --git a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js index 9dc206971a1..c33259a82b6 100644 --- a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js +++ b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js @@ -1,5 +1,4 @@ //// [accessorWithMismatchedAccessibilityModifiers.ts] - class C { get x() { return 1; diff --git a/tests/baselines/reference/accessorWithRestParam.errors.txt b/tests/baselines/reference/accessorWithRestParam.errors.txt index c6f3ef70563..ae06df99c95 100644 --- a/tests/baselines/reference/accessorWithRestParam.errors.txt +++ b/tests/baselines/reference/accessorWithRestParam.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorWithRestParam.ts(3,11): error TS1053: A 'set' accessor cannot have rest parameter. -tests/cases/compiler/accessorWithRestParam.ts(4,18): error TS1053: A 'set' accessor cannot have rest parameter. +tests/cases/compiler/accessorWithRestParam.ts(2,11): error TS1053: A 'set' accessor cannot have rest parameter. +tests/cases/compiler/accessorWithRestParam.ts(3,18): error TS1053: A 'set' accessor cannot have rest parameter. ==== tests/cases/compiler/accessorWithRestParam.ts (2 errors) ==== - class C { set X(...v) { } ~~~ diff --git a/tests/baselines/reference/accessorWithRestParam.js b/tests/baselines/reference/accessorWithRestParam.js index 871f3ed00ef..63169b3cacb 100644 --- a/tests/baselines/reference/accessorWithRestParam.js +++ b/tests/baselines/reference/accessorWithRestParam.js @@ -1,5 +1,4 @@ //// [accessorWithRestParam.ts] - class C { set X(...v) { } static set X(...v2) { } diff --git a/tests/baselines/reference/accessorsInAmbientContext.errors.txt b/tests/baselines/reference/accessorsInAmbientContext.errors.txt index ada59f21f65..44b100bd58d 100644 --- a/tests/baselines/reference/accessorsInAmbientContext.errors.txt +++ b/tests/baselines/reference/accessorsInAmbientContext.errors.txt @@ -1,15 +1,14 @@ +tests/cases/compiler/accessorsInAmbientContext.ts(3,13): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(4,13): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(5,13): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/accessorsInAmbientContext.ts(6,20): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(7,20): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(8,20): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/accessorsInAmbientContext.ts(12,9): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(13,9): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(14,9): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/accessorsInAmbientContext.ts(15,16): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(16,16): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(17,16): error TS1086: An accessor cannot be declared in an ambient context. ==== tests/cases/compiler/accessorsInAmbientContext.ts (8 errors) ==== - declare module M { class C { get X() { return 1; } diff --git a/tests/baselines/reference/accessorsInAmbientContext.js b/tests/baselines/reference/accessorsInAmbientContext.js index e60831ede5b..8e608edae1a 100644 --- a/tests/baselines/reference/accessorsInAmbientContext.js +++ b/tests/baselines/reference/accessorsInAmbientContext.js @@ -1,5 +1,4 @@ //// [accessorsInAmbientContext.ts] - declare module M { class C { get X() { return 1; } diff --git a/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt b/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt index f7d7b146ee3..cee1c8fd537 100644 --- a/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt +++ b/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorsNotAllowedInES3.ts(3,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/accessorsNotAllowedInES3.ts(5,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/accessorsNotAllowedInES3.ts(2,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/accessorsNotAllowedInES3.ts(4,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/compiler/accessorsNotAllowedInES3.ts (2 errors) ==== - class C { get x(): number { return 1; } ~ diff --git a/tests/baselines/reference/accessorsNotAllowedInES3.js b/tests/baselines/reference/accessorsNotAllowedInES3.js index e348771b8f6..2d26c0643f9 100644 --- a/tests/baselines/reference/accessorsNotAllowedInES3.js +++ b/tests/baselines/reference/accessorsNotAllowedInES3.js @@ -1,5 +1,4 @@ //// [accessorsNotAllowedInES3.ts] - class C { get x(): number { return 1; } } diff --git a/tests/baselines/reference/aliasBug.errors.txt b/tests/baselines/reference/aliasBug.errors.txt index 0c8dd7d034f..70f6409ef21 100644 --- a/tests/baselines/reference/aliasBug.errors.txt +++ b/tests/baselines/reference/aliasBug.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/aliasBug.ts(17,15): error TS2694: Namespace 'foo.bar.baz' has no exported member 'bar'. +tests/cases/compiler/aliasBug.ts(16,15): error TS2694: Namespace 'foo.bar.baz' has no exported member 'bar'. ==== tests/cases/compiler/aliasBug.ts (1 errors) ==== - module foo { export class Provide { } diff --git a/tests/baselines/reference/aliasBug.js b/tests/baselines/reference/aliasBug.js index be7201a8ea7..99d45bf1ae0 100644 --- a/tests/baselines/reference/aliasBug.js +++ b/tests/baselines/reference/aliasBug.js @@ -1,5 +1,4 @@ //// [aliasBug.ts] - module foo { export class Provide { } diff --git a/tests/baselines/reference/aliasesInSystemModule1.errors.txt b/tests/baselines/reference/aliasesInSystemModule1.errors.txt index 9b89332e458..d84223cc8a3 100644 --- a/tests/baselines/reference/aliasesInSystemModule1.errors.txt +++ b/tests/baselines/reference/aliasesInSystemModule1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/aliasesInSystemModule1.ts(2,24): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/aliasesInSystemModule1.ts(1,24): error TS2307: Cannot find module 'foo'. ==== tests/cases/compiler/aliasesInSystemModule1.ts (1 errors) ==== - import alias = require('foo'); ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/aliasesInSystemModule1.js b/tests/baselines/reference/aliasesInSystemModule1.js index 24d7a5d1b0b..f940dd04597 100644 --- a/tests/baselines/reference/aliasesInSystemModule1.js +++ b/tests/baselines/reference/aliasesInSystemModule1.js @@ -1,5 +1,4 @@ //// [aliasesInSystemModule1.ts] - import alias = require('foo'); import cls = alias.Class; export import cls2 = alias.Class; diff --git a/tests/baselines/reference/aliasesInSystemModule2.errors.txt b/tests/baselines/reference/aliasesInSystemModule2.errors.txt index 618e61c7f3c..a1456b04cd8 100644 --- a/tests/baselines/reference/aliasesInSystemModule2.errors.txt +++ b/tests/baselines/reference/aliasesInSystemModule2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/aliasesInSystemModule2.ts(2,21): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/aliasesInSystemModule2.ts(1,21): error TS2307: Cannot find module 'foo'. ==== tests/cases/compiler/aliasesInSystemModule2.ts (1 errors) ==== - import {alias} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/aliasesInSystemModule2.js b/tests/baselines/reference/aliasesInSystemModule2.js index 71fe558d43a..5ef48a52cde 100644 --- a/tests/baselines/reference/aliasesInSystemModule2.js +++ b/tests/baselines/reference/aliasesInSystemModule2.js @@ -1,5 +1,4 @@ //// [aliasesInSystemModule2.ts] - import {alias} from "foo"; import cls = alias.Class; export import cls2 = alias.Class; diff --git a/tests/baselines/reference/alwaysStrict.errors.txt b/tests/baselines/reference/alwaysStrict.errors.txt index d7fcfb45801..55ec2eb5880 100644 --- a/tests/baselines/reference/alwaysStrict.errors.txt +++ b/tests/baselines/reference/alwaysStrict.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/alwaysStrict.ts(3,9): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrict.ts(2,9): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/alwaysStrict.ts (1 errors) ==== - function f() { var arguments = []; ~~~~~~~~~ diff --git a/tests/baselines/reference/alwaysStrict.js b/tests/baselines/reference/alwaysStrict.js index bc5f9a29912..c3580ec2c1c 100644 --- a/tests/baselines/reference/alwaysStrict.js +++ b/tests/baselines/reference/alwaysStrict.js @@ -1,5 +1,4 @@ //// [alwaysStrict.ts] - function f() { var arguments = []; } diff --git a/tests/baselines/reference/alwaysStrictES6.errors.txt b/tests/baselines/reference/alwaysStrictES6.errors.txt index b775a6e4755..f59c9a3c040 100644 --- a/tests/baselines/reference/alwaysStrictES6.errors.txt +++ b/tests/baselines/reference/alwaysStrictES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/alwaysStrictES6.ts(3,9): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrictES6.ts(2,9): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/alwaysStrictES6.ts (1 errors) ==== - function f() { var arguments = []; ~~~~~~~~~ diff --git a/tests/baselines/reference/alwaysStrictES6.js b/tests/baselines/reference/alwaysStrictES6.js index 2c7ad36bce2..7b2e0e28e9e 100644 --- a/tests/baselines/reference/alwaysStrictES6.js +++ b/tests/baselines/reference/alwaysStrictES6.js @@ -1,5 +1,4 @@ //// [alwaysStrictES6.ts] - function f() { var arguments = []; } diff --git a/tests/baselines/reference/alwaysStrictModule.errors.txt b/tests/baselines/reference/alwaysStrictModule.errors.txt index 90c1a0b930a..61e3db4a482 100644 --- a/tests/baselines/reference/alwaysStrictModule.errors.txt +++ b/tests/baselines/reference/alwaysStrictModule.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/alwaysStrictModule.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrictModule.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/alwaysStrictModule.ts (1 errors) ==== - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule.js b/tests/baselines/reference/alwaysStrictModule.js index f39c87ed96c..f5c5835df5f 100644 --- a/tests/baselines/reference/alwaysStrictModule.js +++ b/tests/baselines/reference/alwaysStrictModule.js @@ -1,5 +1,4 @@ //// [alwaysStrictModule.ts] - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule2.errors.txt b/tests/baselines/reference/alwaysStrictModule2.errors.txt index 3980d24abfc..ef43d82f33d 100644 --- a/tests/baselines/reference/alwaysStrictModule2.errors.txt +++ b/tests/baselines/reference/alwaysStrictModule2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/a.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. tests/cases/compiler/b.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/a.ts (1 errors) ==== - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule2.js b/tests/baselines/reference/alwaysStrictModule2.js index 54f179ff10b..7ad0b36c4be 100644 --- a/tests/baselines/reference/alwaysStrictModule2.js +++ b/tests/baselines/reference/alwaysStrictModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/alwaysStrictModule2.ts] //// //// [a.ts] - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule3.js b/tests/baselines/reference/alwaysStrictModule3.js index 894bad25143..2eb8de84028 100644 --- a/tests/baselines/reference/alwaysStrictModule3.js +++ b/tests/baselines/reference/alwaysStrictModule3.js @@ -1,8 +1,8 @@ //// [alwaysStrictModule3.ts] - // module ES2015 export const a = 1; //// [alwaysStrictModule3.js] // module ES2015 +// module ES2015 export var a = 1; diff --git a/tests/baselines/reference/alwaysStrictModule3.symbols b/tests/baselines/reference/alwaysStrictModule3.symbols index 6f053673f0e..0e615b13b9d 100644 --- a/tests/baselines/reference/alwaysStrictModule3.symbols +++ b/tests/baselines/reference/alwaysStrictModule3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule3.ts === - // module ES2015 export const a = 1; ->a : Symbol(a, Decl(alwaysStrictModule3.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule3.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule3.types b/tests/baselines/reference/alwaysStrictModule3.types index 75b11206a4f..2c972c392ea 100644 --- a/tests/baselines/reference/alwaysStrictModule3.types +++ b/tests/baselines/reference/alwaysStrictModule3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule3.ts === - // module ES2015 export const a = 1; >a : 1 diff --git a/tests/baselines/reference/alwaysStrictModule4.js b/tests/baselines/reference/alwaysStrictModule4.js index dcaafdfeee6..026570293be 100644 --- a/tests/baselines/reference/alwaysStrictModule4.js +++ b/tests/baselines/reference/alwaysStrictModule4.js @@ -1,5 +1,4 @@ //// [alwaysStrictModule4.ts] - // Module commonjs export const a = 1 diff --git a/tests/baselines/reference/alwaysStrictModule4.symbols b/tests/baselines/reference/alwaysStrictModule4.symbols index 4b8a968ae16..aaaf3d5c11d 100644 --- a/tests/baselines/reference/alwaysStrictModule4.symbols +++ b/tests/baselines/reference/alwaysStrictModule4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule4.ts === - // Module commonjs export const a = 1 ->a : Symbol(a, Decl(alwaysStrictModule4.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule4.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule4.types b/tests/baselines/reference/alwaysStrictModule4.types index fff87967605..134aebd585f 100644 --- a/tests/baselines/reference/alwaysStrictModule4.types +++ b/tests/baselines/reference/alwaysStrictModule4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule4.ts === - // Module commonjs export const a = 1 >a : 1 diff --git a/tests/baselines/reference/alwaysStrictModule5.js b/tests/baselines/reference/alwaysStrictModule5.js index 74b9d72263c..2356df0e393 100644 --- a/tests/baselines/reference/alwaysStrictModule5.js +++ b/tests/baselines/reference/alwaysStrictModule5.js @@ -1,8 +1,8 @@ //// [alwaysStrictModule5.ts] - // Targeting ES6 export const a = 1; //// [alwaysStrictModule5.js] // Targeting ES6 +// Targeting ES6 export const a = 1; diff --git a/tests/baselines/reference/alwaysStrictModule5.symbols b/tests/baselines/reference/alwaysStrictModule5.symbols index 903bf3c5c98..cab5143a740 100644 --- a/tests/baselines/reference/alwaysStrictModule5.symbols +++ b/tests/baselines/reference/alwaysStrictModule5.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule5.ts === - // Targeting ES6 export const a = 1; ->a : Symbol(a, Decl(alwaysStrictModule5.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule5.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule5.types b/tests/baselines/reference/alwaysStrictModule5.types index 2bfa329ad7e..8193c57ee12 100644 --- a/tests/baselines/reference/alwaysStrictModule5.types +++ b/tests/baselines/reference/alwaysStrictModule5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule5.ts === - // Targeting ES6 export const a = 1; >a : 1 diff --git a/tests/baselines/reference/alwaysStrictModule6.js b/tests/baselines/reference/alwaysStrictModule6.js index cd97b55b67b..2c64e06582e 100644 --- a/tests/baselines/reference/alwaysStrictModule6.js +++ b/tests/baselines/reference/alwaysStrictModule6.js @@ -1,5 +1,4 @@ //// [alwaysStrictModule6.ts] - // Targeting ES5 export const a = 1; diff --git a/tests/baselines/reference/alwaysStrictModule6.symbols b/tests/baselines/reference/alwaysStrictModule6.symbols index 59a70f3e5b5..33ed3c37cf4 100644 --- a/tests/baselines/reference/alwaysStrictModule6.symbols +++ b/tests/baselines/reference/alwaysStrictModule6.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule6.ts === - // Targeting ES5 export const a = 1; ->a : Symbol(a, Decl(alwaysStrictModule6.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule6.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule6.types b/tests/baselines/reference/alwaysStrictModule6.types index 0970380911e..dc6e6e34766 100644 --- a/tests/baselines/reference/alwaysStrictModule6.types +++ b/tests/baselines/reference/alwaysStrictModule6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule6.ts === - // Targeting ES5 export const a = 1; >a : 1 diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt index 8df1d76e546..1c228e9b31a 100644 --- a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt +++ b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt @@ -1,10 +1,9 @@ error TS5053: Option 'noImplicitUseStrict' cannot be specified with option 'alwaysStrict'. -tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. !!! error TS5053: Option 'noImplicitUseStrict' cannot be specified with option 'alwaysStrict'. ==== tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts (1 errors) ==== - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js index cfa7f69629f..ff5a1166a89 100644 --- a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js +++ b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js @@ -1,5 +1,4 @@ //// [alwaysStrictNoImplicitUseStrict.ts] - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/ambientClassDeclarationWithExtends.js b/tests/baselines/reference/ambientClassDeclarationWithExtends.js index 940efb8899f..1b7bcf88b20 100644 --- a/tests/baselines/reference/ambientClassDeclarationWithExtends.js +++ b/tests/baselines/reference/ambientClassDeclarationWithExtends.js @@ -13,14 +13,12 @@ declare class D extends C { } var d: C = new D(); //// [ambientClassDeclarationExtends_file1.ts] - declare class E { public bar; } namespace F { var y; } //// [ambientClassDeclarationExtends_file2.ts] - declare class F extends E { } var f: E = new F(); diff --git a/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols b/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols index 125bd0d0e5f..652b3eee3cb 100644 --- a/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols +++ b/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols @@ -26,25 +26,23 @@ var d: C = new D(); >D : Symbol(D, Decl(ambientClassDeclarationExtends_singleFile.ts, 5, 1), Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 22)) === tests/cases/compiler/ambientClassDeclarationExtends_file1.ts === - declare class E { >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0)) public bar; ->bar : Symbol(E.bar, Decl(ambientClassDeclarationExtends_file1.ts, 1, 17)) +>bar : Symbol(E.bar, Decl(ambientClassDeclarationExtends_file1.ts, 0, 17)) } namespace F { var y; } ->F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) ->y : Symbol(y, Decl(ambientClassDeclarationExtends_file1.ts, 4, 17)) +>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 2, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) +>y : Symbol(y, Decl(ambientClassDeclarationExtends_file1.ts, 3, 17)) === tests/cases/compiler/ambientClassDeclarationExtends_file2.ts === - declare class F extends E { } ->F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) +>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 2, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0)) var f: E = new F(); ->f : Symbol(f, Decl(ambientClassDeclarationExtends_file2.ts, 2, 3)) +>f : Symbol(f, Decl(ambientClassDeclarationExtends_file2.ts, 1, 3)) >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0)) ->F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) +>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 2, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) diff --git a/tests/baselines/reference/ambientClassDeclarationWithExtends.types b/tests/baselines/reference/ambientClassDeclarationWithExtends.types index c7f22eeb65f..75040fb08d9 100644 --- a/tests/baselines/reference/ambientClassDeclarationWithExtends.types +++ b/tests/baselines/reference/ambientClassDeclarationWithExtends.types @@ -27,7 +27,6 @@ var d: C = new D(); >D : typeof D === tests/cases/compiler/ambientClassDeclarationExtends_file1.ts === - declare class E { >E : E @@ -39,7 +38,6 @@ namespace F { var y; } >y : any === tests/cases/compiler/ambientClassDeclarationExtends_file2.ts === - declare class F extends E { } >F : F >E : E diff --git a/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols b/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols index 0d9fed77240..6ed3e374e55 100644 --- a/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols +++ b/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/a.d.ts === - declare namespace ns { >ns : Symbol(ns, Decl(a.d.ts, 0, 0)) class SecondNS extends FirstNS { } ->SecondNS : Symbol(SecondNS, Decl(a.d.ts, 1, 22)) ->FirstNS : Symbol(FirstNS, Decl(a.d.ts, 2, 36)) +>SecondNS : Symbol(SecondNS, Decl(a.d.ts, 0, 22)) +>FirstNS : Symbol(FirstNS, Decl(a.d.ts, 1, 36)) class FirstNS { } ->FirstNS : Symbol(FirstNS, Decl(a.d.ts, 2, 36)) +>FirstNS : Symbol(FirstNS, Decl(a.d.ts, 1, 36)) } diff --git a/tests/baselines/reference/ambientClassDeclaredBeforeBase.types b/tests/baselines/reference/ambientClassDeclaredBeforeBase.types index 554d3cfcce8..2e3e5b453e0 100644 --- a/tests/baselines/reference/ambientClassDeclaredBeforeBase.types +++ b/tests/baselines/reference/ambientClassDeclaredBeforeBase.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - declare namespace ns { >ns : typeof ns diff --git a/tests/baselines/reference/ambientConstLiterals.js b/tests/baselines/reference/ambientConstLiterals.js index 4a590826b1d..ca5a5d28699 100644 --- a/tests/baselines/reference/ambientConstLiterals.js +++ b/tests/baselines/reference/ambientConstLiterals.js @@ -1,5 +1,4 @@ //// [ambientConstLiterals.ts] - function f(x: T): T { return x; } diff --git a/tests/baselines/reference/ambientConstLiterals.symbols b/tests/baselines/reference/ambientConstLiterals.symbols index 67d168a0750..3ab4309259a 100644 --- a/tests/baselines/reference/ambientConstLiterals.symbols +++ b/tests/baselines/reference/ambientConstLiterals.symbols @@ -1,74 +1,73 @@ === tests/cases/compiler/ambientConstLiterals.ts === - function f(x: T): T { >f : Symbol(f, Decl(ambientConstLiterals.ts, 0, 0)) ->T : Symbol(T, Decl(ambientConstLiterals.ts, 1, 11)) ->x : Symbol(x, Decl(ambientConstLiterals.ts, 1, 14)) ->T : Symbol(T, Decl(ambientConstLiterals.ts, 1, 11)) ->T : Symbol(T, Decl(ambientConstLiterals.ts, 1, 11)) +>T : Symbol(T, Decl(ambientConstLiterals.ts, 0, 11)) +>x : Symbol(x, Decl(ambientConstLiterals.ts, 0, 14)) +>T : Symbol(T, Decl(ambientConstLiterals.ts, 0, 11)) +>T : Symbol(T, Decl(ambientConstLiterals.ts, 0, 11)) return x; ->x : Symbol(x, Decl(ambientConstLiterals.ts, 1, 14)) +>x : Symbol(x, Decl(ambientConstLiterals.ts, 0, 14)) } enum E { A, B, C } ->E : Symbol(E, Decl(ambientConstLiterals.ts, 3, 1)) ->A : Symbol(E.A, Decl(ambientConstLiterals.ts, 5, 8)) ->B : Symbol(E.B, Decl(ambientConstLiterals.ts, 5, 11)) ->C : Symbol(E.C, Decl(ambientConstLiterals.ts, 5, 14)) +>E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1)) +>A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8)) +>B : Symbol(E.B, Decl(ambientConstLiterals.ts, 4, 11)) +>C : Symbol(E.C, Decl(ambientConstLiterals.ts, 4, 14)) const c1 = "abc"; ->c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 7, 5)) +>c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 6, 5)) const c2 = 123; ->c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 8, 5)) +>c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 7, 5)) const c3 = c1; ->c3 : Symbol(c3, Decl(ambientConstLiterals.ts, 9, 5)) ->c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 7, 5)) +>c3 : Symbol(c3, Decl(ambientConstLiterals.ts, 8, 5)) +>c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 6, 5)) const c4 = c2; ->c4 : Symbol(c4, Decl(ambientConstLiterals.ts, 10, 5)) ->c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 8, 5)) +>c4 : Symbol(c4, Decl(ambientConstLiterals.ts, 9, 5)) +>c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 7, 5)) const c5 = f(123); ->c5 : Symbol(c5, Decl(ambientConstLiterals.ts, 11, 5)) +>c5 : Symbol(c5, Decl(ambientConstLiterals.ts, 10, 5)) >f : Symbol(f, Decl(ambientConstLiterals.ts, 0, 0)) const c6 = f(-123); ->c6 : Symbol(c6, Decl(ambientConstLiterals.ts, 12, 5)) +>c6 : Symbol(c6, Decl(ambientConstLiterals.ts, 11, 5)) >f : Symbol(f, Decl(ambientConstLiterals.ts, 0, 0)) const c7 = true; ->c7 : Symbol(c7, Decl(ambientConstLiterals.ts, 13, 5)) +>c7 : Symbol(c7, Decl(ambientConstLiterals.ts, 12, 5)) const c8 = E.A; ->c8 : Symbol(c8, Decl(ambientConstLiterals.ts, 14, 5)) ->E.A : Symbol(E.A, Decl(ambientConstLiterals.ts, 5, 8)) ->E : Symbol(E, Decl(ambientConstLiterals.ts, 3, 1)) ->A : Symbol(E.A, Decl(ambientConstLiterals.ts, 5, 8)) +>c8 : Symbol(c8, Decl(ambientConstLiterals.ts, 13, 5)) +>E.A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8)) +>E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1)) +>A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8)) const c9 = { x: "abc" }; ->c9 : Symbol(c9, Decl(ambientConstLiterals.ts, 15, 5)) ->x : Symbol(x, Decl(ambientConstLiterals.ts, 15, 12)) +>c9 : Symbol(c9, Decl(ambientConstLiterals.ts, 14, 5)) +>x : Symbol(x, Decl(ambientConstLiterals.ts, 14, 12)) const c10 = [123]; ->c10 : Symbol(c10, Decl(ambientConstLiterals.ts, 16, 5)) +>c10 : Symbol(c10, Decl(ambientConstLiterals.ts, 15, 5)) const c11 = "abc" + "def"; ->c11 : Symbol(c11, Decl(ambientConstLiterals.ts, 17, 5)) +>c11 : Symbol(c11, Decl(ambientConstLiterals.ts, 16, 5)) const c12 = 123 + 456; ->c12 : Symbol(c12, Decl(ambientConstLiterals.ts, 18, 5)) +>c12 : Symbol(c12, Decl(ambientConstLiterals.ts, 17, 5)) const c13 = Math.random() > 0.5 ? "abc" : "def"; ->c13 : Symbol(c13, Decl(ambientConstLiterals.ts, 19, 5)) +>c13 : Symbol(c13, Decl(ambientConstLiterals.ts, 18, 5)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) const c14 = Math.random() > 0.5 ? 123 : 456; ->c14 : Symbol(c14, Decl(ambientConstLiterals.ts, 20, 5)) +>c14 : Symbol(c14, Decl(ambientConstLiterals.ts, 19, 5)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/ambientConstLiterals.types b/tests/baselines/reference/ambientConstLiterals.types index 8b6fc984628..6f8a477b94d 100644 --- a/tests/baselines/reference/ambientConstLiterals.types +++ b/tests/baselines/reference/ambientConstLiterals.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ambientConstLiterals.ts === - function f(x: T): T { >f : (x: T) => T >T : T diff --git a/tests/baselines/reference/ambientDeclarationsExternal.js b/tests/baselines/reference/ambientDeclarationsExternal.js index dfff030b78f..fb531586467 100644 --- a/tests/baselines/reference/ambientDeclarationsExternal.js +++ b/tests/baselines/reference/ambientDeclarationsExternal.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/ambient/ambientDeclarationsExternal.ts] //// //// [decls.ts] - // Ambient external module with export assignment declare module 'equ' { var x; diff --git a/tests/baselines/reference/ambientDeclarationsExternal.symbols b/tests/baselines/reference/ambientDeclarationsExternal.symbols index f160751a19b..57d3fdf914f 100644 --- a/tests/baselines/reference/ambientDeclarationsExternal.symbols +++ b/tests/baselines/reference/ambientDeclarationsExternal.symbols @@ -10,27 +10,26 @@ import imp3 = require('equ2'); var n = imp3.x; >n : Symbol(n, Decl(consumer.ts, 6, 3), Decl(consumer.ts, 7, 3)) ->imp3.x : Symbol(imp3.x, Decl(decls.ts, 8, 7)) +>imp3.x : Symbol(imp3.x, Decl(decls.ts, 7, 7)) >imp3 : Symbol(imp3, Decl(consumer.ts, 1, 29)) ->x : Symbol(imp3.x, Decl(decls.ts, 8, 7)) +>x : Symbol(imp3.x, Decl(decls.ts, 7, 7)) var n: number; >n : Symbol(n, Decl(consumer.ts, 6, 3), Decl(consumer.ts, 7, 3)) === tests/cases/conformance/ambient/decls.ts === - // Ambient external module with export assignment declare module 'equ' { var x; ->x : Symbol(x, Decl(decls.ts, 3, 7)) +>x : Symbol(x, Decl(decls.ts, 2, 7)) export = x; ->x : Symbol(x, Decl(decls.ts, 3, 7)) +>x : Symbol(x, Decl(decls.ts, 2, 7)) } declare module 'equ2' { var x: number; ->x : Symbol(x, Decl(decls.ts, 8, 7)) +>x : Symbol(x, Decl(decls.ts, 7, 7)) } // Ambient external import declaration referencing ambient external module using top level module name diff --git a/tests/baselines/reference/ambientDeclarationsExternal.types b/tests/baselines/reference/ambientDeclarationsExternal.types index 062e006cf0a..4cf7d6b0bcb 100644 --- a/tests/baselines/reference/ambientDeclarationsExternal.types +++ b/tests/baselines/reference/ambientDeclarationsExternal.types @@ -18,7 +18,6 @@ var n: number; >n : number === tests/cases/conformance/ambient/decls.ts === - // Ambient external module with export assignment declare module 'equ' { var x; diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt index 4edf3bf7966..0757ba10e2e 100644 --- a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(5,16): error TS2664: Invalid module name in augmentation, module 'ext' cannot be found. -tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(10,22): error TS2307: Cannot find module 'ext'. +tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(4,16): error TS2664: Invalid module name in augmentation, module 'ext' cannot be found. +tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(9,22): error TS2307: Cannot find module 'ext'. ==== tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts (2 errors) ==== - class D { } export = D; diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js index b0382205cd3..0e5bb55036c 100644 --- a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js @@ -1,5 +1,4 @@ //// [ambientExternalModuleInAnotherExternalModule.ts] - class D { } export = D; diff --git a/tests/baselines/reference/ambientGetters.errors.txt b/tests/baselines/reference/ambientGetters.errors.txt index a56020c41fb..b245f561813 100644 --- a/tests/baselines/reference/ambientGetters.errors.txt +++ b/tests/baselines/reference/ambientGetters.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/ambientGetters.ts(3,9): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/ambientGetters.ts(7,9): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/ambientGetters.ts(2,9): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/ambientGetters.ts(6,9): error TS1086: An accessor cannot be declared in an ambient context. ==== tests/cases/compiler/ambientGetters.ts (2 errors) ==== - declare class A { get length() : number; ~~~~~~ diff --git a/tests/baselines/reference/ambientGetters.js b/tests/baselines/reference/ambientGetters.js index 9e267a1dddb..db2310646af 100644 --- a/tests/baselines/reference/ambientGetters.js +++ b/tests/baselines/reference/ambientGetters.js @@ -1,5 +1,4 @@ //// [ambientGetters.ts] - declare class A { get length() : number; } diff --git a/tests/baselines/reference/ambientRequireFunction.js b/tests/baselines/reference/ambientRequireFunction.js index cd00b287c82..348ee0a1443 100644 --- a/tests/baselines/reference/ambientRequireFunction.js +++ b/tests/baselines/reference/ambientRequireFunction.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/ambientRequireFunction.ts] //// //// [node.d.ts] - - declare function require(moduleName: string): any; declare module "fs" { diff --git a/tests/baselines/reference/ambientRequireFunction.symbols b/tests/baselines/reference/ambientRequireFunction.symbols index 6afb47e37fb..11f91a66357 100644 --- a/tests/baselines/reference/ambientRequireFunction.symbols +++ b/tests/baselines/reference/ambientRequireFunction.symbols @@ -4,24 +4,22 @@ const fs = require("fs"); >fs : Symbol(fs, Decl(app.js, 2, 5)) >require : Symbol(require, Decl(node.d.ts, 0, 0)) ->"fs" : Symbol("fs", Decl(node.d.ts, 2, 50)) +>"fs" : Symbol("fs", Decl(node.d.ts, 0, 50)) const text = fs.readFileSync("/a/b/c"); >text : Symbol(text, Decl(app.js, 3, 5)) ->fs.readFileSync : Symbol(readFileSync, Decl(node.d.ts, 4, 21)) +>fs.readFileSync : Symbol(readFileSync, Decl(node.d.ts, 2, 21)) >fs : Symbol(fs, Decl(app.js, 2, 5)) ->readFileSync : Symbol(readFileSync, Decl(node.d.ts, 4, 21)) +>readFileSync : Symbol(readFileSync, Decl(node.d.ts, 2, 21)) === tests/cases/compiler/node.d.ts === - - declare function require(moduleName: string): any; >require : Symbol(require, Decl(node.d.ts, 0, 0)) ->moduleName : Symbol(moduleName, Decl(node.d.ts, 2, 25)) +>moduleName : Symbol(moduleName, Decl(node.d.ts, 0, 25)) declare module "fs" { export function readFileSync(s: string): string; ->readFileSync : Symbol(readFileSync, Decl(node.d.ts, 4, 21)) ->s : Symbol(s, Decl(node.d.ts, 5, 33)) +>readFileSync : Symbol(readFileSync, Decl(node.d.ts, 2, 21)) +>s : Symbol(s, Decl(node.d.ts, 3, 33)) } diff --git a/tests/baselines/reference/ambientRequireFunction.types b/tests/baselines/reference/ambientRequireFunction.types index e0341d97ec3..73a163f860b 100644 --- a/tests/baselines/reference/ambientRequireFunction.types +++ b/tests/baselines/reference/ambientRequireFunction.types @@ -16,8 +16,6 @@ const text = fs.readFileSync("/a/b/c"); >"/a/b/c" : "/a/b/c" === tests/cases/compiler/node.d.ts === - - declare function require(moduleName: string): any; >require : (moduleName: string) => any >moduleName : string diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt index d607ab65d29..2a7be0262cf 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt +++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/argumentsObjectIterator01_ES5.ts(4,21): error TS2495: Type 'IArguments' is not an array type or a string type. +tests/cases/compiler/argumentsObjectIterator01_ES5.ts(3,21): error TS2495: Type 'IArguments' is not an array type or a string type. ==== tests/cases/compiler/argumentsObjectIterator01_ES5.ts (1 errors) ==== - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let result = []; for (let arg of arguments) { diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.js b/tests/baselines/reference/argumentsObjectIterator01_ES5.js index 8378528dbf4..02b0a059a35 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES5.js +++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator01_ES5.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let result = []; for (let arg of arguments) { diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.js b/tests/baselines/reference/argumentsObjectIterator01_ES6.js index 03744f16b99..ade88debd87 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.js +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator01_ES6.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let result = []; for (let arg of arguments) { diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols index 384b4458b2f..aaa7431408b 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/argumentsObjectIterator01_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator01_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(argumentsObjectIterator01_ES6.ts, 1, 32)) ->y : Symbol(y, Decl(argumentsObjectIterator01_ES6.ts, 1, 42)) ->z : Symbol(z, Decl(argumentsObjectIterator01_ES6.ts, 1, 53)) +>x : Symbol(x, Decl(argumentsObjectIterator01_ES6.ts, 0, 32)) +>y : Symbol(y, Decl(argumentsObjectIterator01_ES6.ts, 0, 42)) +>z : Symbol(z, Decl(argumentsObjectIterator01_ES6.ts, 0, 53)) let result = []; ->result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7)) for (let arg of arguments) { ->arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12)) >arguments : Symbol(arguments) result.push(arg + arg); >result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) ->arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12)) } return <[any, any, any]>result; ->result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7)) } diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.types b/tests/baselines/reference/argumentsObjectIterator01_ES6.types index 04e3bfe081f..a4f1b83896b 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/argumentsObjectIterator01_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number] >x : number diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt index 125f69b90b2..6e530bc49ff 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt +++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/argumentsObjectIterator02_ES5.ts(3,26): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/argumentsObjectIterator02_ES5.ts(2,26): error TS2304: Cannot find name 'Symbol'. ==== tests/cases/compiler/argumentsObjectIterator02_ES5.ts (1 errors) ==== - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let blah = arguments[Symbol.iterator]; ~~~~~~ diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.js b/tests/baselines/reference/argumentsObjectIterator02_ES5.js index 366bf8de199..ae8675d9745 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES5.js +++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator02_ES5.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let blah = arguments[Symbol.iterator]; diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.js b/tests/baselines/reference/argumentsObjectIterator02_ES6.js index 9b9415afd29..1155ab929ea 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.js +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator02_ES6.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let blah = arguments[Symbol.iterator]; diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols index 974d668bc1f..64b82088e1a 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/argumentsObjectIterator02_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator02_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(argumentsObjectIterator02_ES6.ts, 1, 32)) ->y : Symbol(y, Decl(argumentsObjectIterator02_ES6.ts, 1, 42)) ->z : Symbol(z, Decl(argumentsObjectIterator02_ES6.ts, 1, 53)) +>x : Symbol(x, Decl(argumentsObjectIterator02_ES6.ts, 0, 32)) +>y : Symbol(y, Decl(argumentsObjectIterator02_ES6.ts, 0, 42)) +>z : Symbol(z, Decl(argumentsObjectIterator02_ES6.ts, 0, 53)) let blah = arguments[Symbol.iterator]; ->blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) +>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 1, 7)) >arguments : Symbol(arguments) >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) let result = []; ->result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7)) for (let arg of blah()) { ->arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) ->blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12)) +>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 1, 7)) result.push(arg + arg); >result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) ->arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12)) } return <[any, any, any]>result; ->result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7)) } diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.types b/tests/baselines/reference/argumentsObjectIterator02_ES6.types index 3812107f3be..a494a45f935 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/argumentsObjectIterator02_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number] >x : number diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt index c39ea238317..d8e58482655 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt +++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/argumentsObjectIterator03_ES5.ts(3,9): error TS2461: Type 'IArguments' is not an array type. +tests/cases/compiler/argumentsObjectIterator03_ES5.ts(2,9): error TS2461: Type 'IArguments' is not an array type. ==== tests/cases/compiler/argumentsObjectIterator03_ES5.ts (1 errors) ==== - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { let [x, y, z] = arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.js b/tests/baselines/reference/argumentsObjectIterator03_ES5.js index 7ea7e7b6593..837808a6d92 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES5.js +++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator03_ES5.ts] - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { let [x, y, z] = arguments; diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.js b/tests/baselines/reference/argumentsObjectIterator03_ES6.js index 788887e86eb..789bcc9390d 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES6.js +++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator03_ES6.ts] - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { let [x, y, z] = arguments; diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols index 97677123f35..21ad6d052f1 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/argumentsObjectIterator03_ES6.ts === - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { >asReversedTuple : Symbol(asReversedTuple, Decl(argumentsObjectIterator03_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(argumentsObjectIterator03_ES6.ts, 1, 25)) ->b : Symbol(b, Decl(argumentsObjectIterator03_ES6.ts, 1, 35)) ->c : Symbol(c, Decl(argumentsObjectIterator03_ES6.ts, 1, 46)) +>a : Symbol(a, Decl(argumentsObjectIterator03_ES6.ts, 0, 25)) +>b : Symbol(b, Decl(argumentsObjectIterator03_ES6.ts, 0, 35)) +>c : Symbol(c, Decl(argumentsObjectIterator03_ES6.ts, 0, 46)) let [x, y, z] = arguments; ->x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 2, 9)) ->y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 2, 11)) ->z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 2, 14)) +>x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 1, 9)) +>y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 1, 11)) +>z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 1, 14)) >arguments : Symbol(arguments) return [z, y, x]; ->z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 2, 14)) ->y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 2, 11)) ->x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 2, 9)) +>z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 1, 14)) +>y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 1, 11)) +>x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 1, 9)) } diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.types b/tests/baselines/reference/argumentsObjectIterator03_ES6.types index 95188dee0c8..5318f7692ea 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/argumentsObjectIterator03_ES6.ts === - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { >asReversedTuple : (a: number, b: string, c: boolean) => [boolean, string, number] >a : number diff --git a/tests/baselines/reference/arrayAssignmentTest4.errors.txt b/tests/baselines/reference/arrayAssignmentTest4.errors.txt index ecded3a3bfd..0fb8112aa92 100644 --- a/tests/baselines/reference/arrayAssignmentTest4.errors.txt +++ b/tests/baselines/reference/arrayAssignmentTest4.errors.txt @@ -1,12 +1,10 @@ -tests/cases/compiler/arrayAssignmentTest4.ts(24,1): error TS2322: Type '() => any' is not assignable to type 'any[]'. +tests/cases/compiler/arrayAssignmentTest4.ts(22,1): error TS2322: Type '() => any' is not assignable to type 'any[]'. Property 'push' is missing in type '() => any'. -tests/cases/compiler/arrayAssignmentTest4.ts(25,1): error TS2322: Type 'C3' is not assignable to type 'any[]'. +tests/cases/compiler/arrayAssignmentTest4.ts(23,1): error TS2322: Type 'C3' is not assignable to type 'any[]'. Property 'length' is missing in type 'C3'. ==== tests/cases/compiler/arrayAssignmentTest4.ts (2 errors) ==== - - class C3 { CM3M1() { return 3;} } diff --git a/tests/baselines/reference/arrayAssignmentTest4.js b/tests/baselines/reference/arrayAssignmentTest4.js index 6cc59bdece4..31e826a0641 100644 --- a/tests/baselines/reference/arrayAssignmentTest4.js +++ b/tests/baselines/reference/arrayAssignmentTest4.js @@ -1,6 +1,4 @@ //// [arrayAssignmentTest4.ts] - - class C3 { CM3M1() { return 3;} } diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js index a6f01d7b75c..916eee62183 100644 --- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js +++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js @@ -1,5 +1,4 @@ //// [arrayBindingPatternOmittedExpressions.ts] - var results: string[]; { diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols index 41d04ee623a..82421e2ef30 100644 --- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols +++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/arrayBindingPatternOmittedExpressions.ts === - var results: string[]; ->results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 1, 3)) +>results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 0, 3)) { let [, b, , a] = results; ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 10)) ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 15)) ->results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 1, 3)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 3, 10)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 3, 15)) +>results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 0, 3)) let x = { ->x : Symbol(x, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 7)) +>x : Symbol(x, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 7)) a, ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 13)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 13)) b ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 6, 10)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 10)) } } function f([, a, , b, , , , s, , , ] = results) { ->f : Symbol(f, Decl(arrayBindingPatternOmittedExpressions.ts, 9, 1)) ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 13)) ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 18)) ->s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 27)) ->results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 1, 3)) +>f : Symbol(f, Decl(arrayBindingPatternOmittedExpressions.ts, 8, 1)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 13)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 18)) +>s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 27)) +>results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 0, 3)) a = s[1]; ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 13)) ->s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 27)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 13)) +>s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 27)) b = s[2]; ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 18)) ->s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 27)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 18)) +>s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 27)) } diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types index 38649f2b02d..83cde401c22 100644 --- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types +++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types @@ -1,5 +1,4 @@ === tests/cases/compiler/arrayBindingPatternOmittedExpressions.ts === - var results: string[]; >results : string[] diff --git a/tests/baselines/reference/arrowFunctionContexts.errors.txt b/tests/baselines/reference/arrowFunctionContexts.errors.txt index 461d84052d9..df158dec25e 100644 --- a/tests/baselines/reference/arrowFunctionContexts.errors.txt +++ b/tests/baselines/reference/arrowFunctionContexts.errors.txt @@ -1,17 +1,16 @@ -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(3,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(3,7): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(19,1): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(31,9): error TS2322: Type '() => number' is not assignable to type 'E'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(32,16): error TS2332: 'this' cannot be referenced in current location. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(44,5): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(44,11): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(60,5): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,13): error TS2322: Type '() => number' is not assignable to type 'E'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(73,20): error TS2332: 'this' cannot be referenced in current location. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(2,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(2,7): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(18,1): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(30,9): error TS2322: Type '() => number' is not assignable to type 'E'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(31,16): error TS2332: 'this' cannot be referenced in current location. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(43,5): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(43,11): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(59,5): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(71,13): error TS2322: Type '() => number' is not assignable to type 'E'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,20): error TS2332: 'this' cannot be referenced in current location. ==== tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts (10 errors) ==== - // Arrow function used in with statement with (window) { ~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/arrowFunctionContexts.js b/tests/baselines/reference/arrowFunctionContexts.js index 2285aadd3d5..e2407db768a 100644 --- a/tests/baselines/reference/arrowFunctionContexts.js +++ b/tests/baselines/reference/arrowFunctionContexts.js @@ -1,5 +1,4 @@ //// [arrowFunctionContexts.ts] - // Arrow function used in with statement with (window) { var p = () => this; diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js index daaff29cad9..6e38ade3141 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js @@ -1,5 +1,4 @@ //// [arrowFunctionWithParameterNameAsync_es2017.ts] - const x = async => async; //// [arrowFunctionWithParameterNameAsync_es2017.js] diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols index 481697c0afd..2a4b1a95b58 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es2017.ts === - const x = async => async; ->x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 1, 5)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 1, 9)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 1, 9)) +>x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 0, 5)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 0, 9)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 0, 9)) diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types index ccb8654284c..5e9d0d089f2 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es2017.ts === - const x = async => async; >x : (async: any) => any >async => async : (async: any) => any diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js index df308028361..324121a1efb 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js @@ -1,5 +1,4 @@ //// [arrowFunctionWithParameterNameAsync_es5.ts] - const x = async => async; //// [arrowFunctionWithParameterNameAsync_es5.js] diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols index 43c9c343efe..47a150ca02d 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es5.ts === - const x = async => async; ->x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 1, 5)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 1, 9)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 1, 9)) +>x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 0, 5)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 0, 9)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 0, 9)) diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types index bd567320f1d..af963d2be04 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es5.ts === - const x = async => async; >x : (async: any) => any >async => async : (async: any) => any diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js index 8527fefc50d..a3b69bcab67 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js @@ -1,5 +1,4 @@ //// [arrowFunctionWithParameterNameAsync_es6.ts] - const x = async => async; //// [arrowFunctionWithParameterNameAsync_es6.js] diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols index 73e5f31aeb3..102ea23fc39 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es6.ts === - const x = async => async; ->x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 1, 5)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 1, 9)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 1, 9)) +>x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 0, 5)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 0, 9)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 0, 9)) diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types index b6a19fe30ed..8502a206f4a 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es6.ts === - const x = async => async; >x : (async: any) => any >async => async : (async: any) => any diff --git a/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt b/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt index ee87a6b8dd4..988a98c3280 100644 --- a/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt +++ b/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt @@ -1,31 +1,30 @@ -tests/cases/compiler/arrowFunctionsMissingTokens.ts(3,16): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(5,22): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(7,17): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(9,36): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(11,42): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(16,23): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(18,29): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(20,24): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(22,43): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(24,49): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(26,23): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(30,23): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(32,29): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(34,24): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(36,43): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(38,49): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(40,23): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(41,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(42,1): error TS1128: Declaration or statement expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(45,14): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(47,21): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(49,14): error TS2304: Cannot find name 'x'. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(51,35): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(53,41): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(2,16): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(4,22): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(6,17): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(8,36): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(10,42): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(15,23): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(17,29): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(19,24): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(21,43): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(23,49): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(25,23): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(29,23): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(31,29): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(33,24): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(35,43): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(37,49): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(39,23): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(40,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(41,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(44,14): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(46,21): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(48,14): error TS2304: Cannot find name 'x'. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(50,35): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(52,41): error TS1005: '=>' expected. ==== tests/cases/compiler/arrowFunctionsMissingTokens.ts (24 errors) ==== - module missingArrowsWithCurly { var a = () { }; ~ diff --git a/tests/baselines/reference/arrowFunctionsMissingTokens.js b/tests/baselines/reference/arrowFunctionsMissingTokens.js index ef4476f6e45..d0a8bde2a53 100644 --- a/tests/baselines/reference/arrowFunctionsMissingTokens.js +++ b/tests/baselines/reference/arrowFunctionsMissingTokens.js @@ -1,5 +1,4 @@ //// [arrowFunctionsMissingTokens.ts] - module missingArrowsWithCurly { var a = () { }; diff --git a/tests/baselines/reference/asOperator4.js b/tests/baselines/reference/asOperator4.js index 3a43f328f35..d0eac5bb113 100644 --- a/tests/baselines/reference/asOperator4.js +++ b/tests/baselines/reference/asOperator4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/expressions/asOperator/asOperator4.ts] //// //// [foo.ts] - export function foo() { } //// [bar.ts] diff --git a/tests/baselines/reference/asOperator4.symbols b/tests/baselines/reference/asOperator4.symbols index 4ee5f6fe83f..276c0706069 100644 --- a/tests/baselines/reference/asOperator4.symbols +++ b/tests/baselines/reference/asOperator4.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/asOperator/foo.ts === - export function foo() { } >foo : Symbol(foo, Decl(foo.ts, 0, 0)) diff --git a/tests/baselines/reference/asOperator4.types b/tests/baselines/reference/asOperator4.types index 0dc6be46a2c..c60cfc19e32 100644 --- a/tests/baselines/reference/asOperator4.types +++ b/tests/baselines/reference/asOperator4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/asOperator/foo.ts === - export function foo() { } >foo : () => void diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js index caf90acae5f..40ec54d0ac5 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsAmbientExternalModule01.ts] - var declare: number; var module: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols index c35432b7ece..87e75ef0d00 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule01.ts === - var declare: number; ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 0, 3)) var module: string; ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) declare // this is the identifier 'declare' ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 0, 3)) module // this is the identifier 'module' ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) "my external module" // this is just a string { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types index 744687429ce..1b690aee048 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule01.ts === - var declare: number; >declare : number diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js index 20e2693ba7f..74cd41de622 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsAmbientExternalModule02.ts] - var declare: number; var module: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols index ed97f39fc11..ecc5728b32f 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule02.ts === - var declare: number; ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 0, 3)) var module: string; ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) module container { ->container : Symbol(container, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 2, 19)) +>container : Symbol(container, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 19)) declare // this is the identifier 'declare' ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 0, 3)) module // this is the identifier 'module' ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) "my external module" // this is just a string { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types index ae82f5f68a4..d4c769fa50a 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule02.ts === - var declare: number; >declare : number diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface01.js b/tests/baselines/reference/asiPreventsParsingAsInterface01.js index 024ad54371f..4d0215454b6 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface01.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface01.ts] - var interface: number, I: string; interface // This should be the identifier 'interface' diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols index d92c13e8ceb..b353c406cc6 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface01.ts === - var interface: number, I: string; ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 1, 3)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 1, 22)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 0, 3)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 0, 22)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 1, 3)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 0, 3)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 1, 22)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 0, 22)) {} // This should be a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface01.types b/tests/baselines/reference/asiPreventsParsingAsInterface01.types index 03c1b9fc412..101b2c8f96b 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface01.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface01.ts === - var interface: number, I: string; >interface : number >I : string diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface02.js b/tests/baselines/reference/asiPreventsParsingAsInterface02.js index 0ea0421550a..d38cc228d2e 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface02.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface02.ts] - function f(interface: number, I: string) { interface // This should be the identifier 'interface' I // This should be the identifier 'I' diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols index e1e4febe38c..ea22e5f24b3 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface02.ts === - function f(interface: number, I: string) { >f : Symbol(f, Decl(asiPreventsParsingAsInterface02.ts, 0, 0)) ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 1, 11)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 1, 29)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 0, 11)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 0, 29)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 1, 11)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 0, 11)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 1, 29)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 0, 29)) {} // This should be a block body } diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface02.types b/tests/baselines/reference/asiPreventsParsingAsInterface02.types index 7989cc810a8..5477fd1c071 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface02.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface02.ts === - function f(interface: number, I: string) { >f : (interface: number, I: string) => void >interface : number diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface03.js b/tests/baselines/reference/asiPreventsParsingAsInterface03.js index 3b3c836f7f4..b35c94de5b2 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface03.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface03.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface03.ts] - var interface: number, I: string; namespace n { diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols index e8c95cf1244..25d220dec6a 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface03.ts === - var interface: number, I: string; ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 1, 3)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 1, 22)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 0, 3)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 0, 22)) namespace n { ->n : Symbol(n, Decl(asiPreventsParsingAsInterface03.ts, 1, 33)) +>n : Symbol(n, Decl(asiPreventsParsingAsInterface03.ts, 0, 33)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 1, 3)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 0, 3)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 1, 22)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 0, 22)) {} // This should be a block body } diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface03.types b/tests/baselines/reference/asiPreventsParsingAsInterface03.types index a58d502fc25..23c90ad8cce 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface03.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface03.ts === - var interface: number, I: string; >interface : number >I : string diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface04.js b/tests/baselines/reference/asiPreventsParsingAsInterface04.js index 1700636e522..1c39f09d596 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface04.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface04.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface04.ts] - var declare: boolean, interface: number, I: string; declare // This should be the identifier 'declare' diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols index 094411ebed5..e7e91ffd3c5 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface04.ts === - var declare: boolean, interface: number, I: string; ->declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 1, 3)) ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 1, 21)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 1, 40)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 0, 3)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 0, 21)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 0, 40)) declare // This should be the identifier 'declare' ->declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 0, 3)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 1, 21)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 0, 21)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 1, 40)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 0, 40)) {} // This should be a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface04.types b/tests/baselines/reference/asiPreventsParsingAsInterface04.types index f6d29749ae1..d616eccf6e0 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface04.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface04.ts === - var declare: boolean, interface: number, I: string; >declare : boolean >interface : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace01.js b/tests/baselines/reference/asiPreventsParsingAsNamespace01.js index 282d9dd1c7c..f471b93e3c9 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace01.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace01.ts] - var namespace: number; var n: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols index b196d733352..70c53a50611 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace01.ts === - var namespace: number; ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 0, 3)) var n: string; ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) namespace // this is the identifier 'namespace' ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 0, 3)) n // this is the identifier 'n' ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace01.types b/tests/baselines/reference/asiPreventsParsingAsNamespace01.types index 417a96dbed4..5fbee41f3f2 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace01.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace01.ts === - var namespace: number; >namespace : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace02.js b/tests/baselines/reference/asiPreventsParsingAsNamespace02.js index 514a026dc78..c3a09147a9b 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace02.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace02.ts] - var module: number; var m: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols index a3bb37c73bc..019e54bc415 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace02.ts === - var module: number; ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 0, 3)) var m: string; ->m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 2, 3)) +>m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) module // this is the identifier 'namespace' ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 0, 3)) m // this is the identifier 'm' ->m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 2, 3)) +>m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace02.types b/tests/baselines/reference/asiPreventsParsingAsNamespace02.types index e9e1433be7a..efc95969ecc 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace02.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace02.ts === - var module: number; >module : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace03.js b/tests/baselines/reference/asiPreventsParsingAsNamespace03.js index 3c27694f5ce..306ad1baf49 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace03.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace03.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace03.ts] - var namespace: number; var n: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols index e77d012a1bf..8cd929e1986 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace03.ts === - var namespace: number; ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 0, 3)) var n: string; ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) namespace container { ->container : Symbol(container, Decl(asiPreventsParsingAsNamespace03.ts, 2, 14)) +>container : Symbol(container, Decl(asiPreventsParsingAsNamespace03.ts, 1, 14)) namespace // this is the identifier 'namespace' ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 0, 3)) n // this is the identifier 'n' ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) { } // this is a block body } diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace03.types b/tests/baselines/reference/asiPreventsParsingAsNamespace03.types index f119a789e11..918383e4cb1 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace03.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace03.ts === - var namespace: number; >namespace : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.js b/tests/baselines/reference/asiPreventsParsingAsNamespace04.js index 704c8893e76..b8de05cf860 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace04.ts] - let module = 10; module in {} diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols index 60d1f8fcc48..fcacb36dba1 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace04.ts === - let module = 10; ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 0, 3)) module in {} ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 0, 3)) diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.types b/tests/baselines/reference/asiPreventsParsingAsNamespace04.types index 7cab2a7be36..0492d79e9a5 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace04.ts === - let module = 10; >module : number >10 : 10 diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace05.js b/tests/baselines/reference/asiPreventsParsingAsNamespace05.js index 35f557328c0..d7cab5ae283 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace05.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace05.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace05.ts] - let namespace = 10; namespace a.b { export let c = 20; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols index 47f05862b0a..35e69ef56f8 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols @@ -1,24 +1,23 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace05.ts === - let namespace = 10; ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 0, 3)) namespace a.b { ->a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 1, 19)) ->b : Symbol(b, Decl(asiPreventsParsingAsNamespace05.ts, 2, 12)) +>a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 0, 19)) +>b : Symbol(b, Decl(asiPreventsParsingAsNamespace05.ts, 1, 12)) export let c = 20; ->c : Symbol(c, Decl(asiPreventsParsingAsNamespace05.ts, 3, 14)) +>c : Symbol(c, Decl(asiPreventsParsingAsNamespace05.ts, 2, 14)) } namespace ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 0, 3)) a.b.c ->a.b.c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 3, 14)) ->a.b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 2, 12)) ->a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 1, 19)) ->b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 2, 12)) ->c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 3, 14)) +>a.b.c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 2, 14)) +>a.b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 1, 12)) +>a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 0, 19)) +>b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 1, 12)) +>c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 2, 14)) { } diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace05.types b/tests/baselines/reference/asiPreventsParsingAsNamespace05.types index e1492c8c582..98e94c9dc27 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace05.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace05.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace05.ts === - let namespace = 10; >namespace : number >10 : 10 diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js index b05988290cb..7a7ec322eea 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsTypeAlias01.ts] - var type; var string; var Foo; diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols index fa82d53ac70..eaf10d109d3 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols @@ -1,18 +1,17 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias01.ts === - var type; ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 0, 3)) var string; ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) var Foo; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) type ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 0, 3)) Foo = string; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 3, 3)) ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types index 7492a698e3a..2c3d1f80912 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias01.ts === - var type; >type : any diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js index eae9898c8d4..db6215388ff 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsTypeAlias02.ts] - var type; var string; var Foo; diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols index 4b83dba4c5d..23761438119 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols @@ -1,21 +1,20 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias02.ts === - var type; ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 0, 3)) var string; ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) var Foo; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) namespace container { ->container : Symbol(container, Decl(asiPreventsParsingAsTypeAlias02.ts, 3, 8)) +>container : Symbol(container, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 8)) type ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 0, 3)) Foo = string; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 3, 3)) ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) } diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types index 1e6c7a8caf1..62e71637127 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias02.ts === - var type; >type : any diff --git a/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt index 923dbed6dad..45ae071639c 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts(4,11): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts(3,11): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts (1 errors) ==== - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es2017.js b/tests/baselines/reference/asyncArrowFunction10_es2017.js index 3c966201bc2..3fd29302a36 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction10_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction10_es2017.ts] - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt index 0b3596282ff..5b4505ebfde 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts(4,11): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts(3,11): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts (1 errors) ==== - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es5.js b/tests/baselines/reference/asyncArrowFunction10_es5.js index 2fc2ac56f9f..5fc37de5f18 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es5.js +++ b/tests/baselines/reference/asyncArrowFunction10_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction10_es5.ts] - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt index b5ea2a9d926..a5a6b45b45b 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(4,11): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(3,11): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts (1 errors) ==== - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.js b/tests/baselines/reference/asyncArrowFunction10_es6.js index 301e41544bb..78c8b64327f 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es6.js +++ b/tests/baselines/reference/asyncArrowFunction10_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction10_es6.ts] - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.js b/tests/baselines/reference/asyncArrowFunction1_es2017.js index ff6a4624242..b946bc99428 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction1_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction1_es2017.ts] - var foo = async (): Promise => { }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.symbols b/tests/baselines/reference/asyncArrowFunction1_es2017.symbols index 239a057aa88..15739132d35 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es2017.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es2017.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017.ts === - var foo = async (): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction1_es2017.ts, 1, 3)) +>foo : Symbol(foo, Decl(asyncArrowFunction1_es2017.ts, 0, 3)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.types b/tests/baselines/reference/asyncArrowFunction1_es2017.types index bdc6cacc917..3f2c057e61f 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es2017.types +++ b/tests/baselines/reference/asyncArrowFunction1_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017.ts === - var foo = async (): Promise => { >foo : () => Promise >async (): Promise => {} : () => Promise diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.js b/tests/baselines/reference/asyncArrowFunction1_es5.js index aac185c63a1..e26770d8fe9 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es5.js +++ b/tests/baselines/reference/asyncArrowFunction1_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction1_es5.ts] - var foo = async (): Promise => { }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.symbols b/tests/baselines/reference/asyncArrowFunction1_es5.symbols index 9f09c3ac9ad..914165f525b 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es5.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es5.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction1_es5.ts === - var foo = async (): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction1_es5.ts, 1, 3)) +>foo : Symbol(foo, Decl(asyncArrowFunction1_es5.ts, 0, 3)) >Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.types b/tests/baselines/reference/asyncArrowFunction1_es5.types index bde82d2b836..062cfd88974 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es5.types +++ b/tests/baselines/reference/asyncArrowFunction1_es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction1_es5.ts === - var foo = async (): Promise => { >foo : () => Promise >async (): Promise => {} : () => Promise diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js index 0026cd91a7e..202864364f3 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.js +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction1_es6.ts] - var foo = async (): Promise => { }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols index bc3557865ee..2ef65441ff9 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts === - var foo = async (): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) +>foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 0, 3)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.types b/tests/baselines/reference/asyncArrowFunction1_es6.types index 3ecfdeb7919..f3c5d0887f1 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.types +++ b/tests/baselines/reference/asyncArrowFunction1_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts === - var foo = async (): Promise => { >foo : () => Promise >async (): Promise => {} : () => Promise diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt index 3df56177107..a2504b35e68 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,18): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,24): error TS1005: ',' expected. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,33): error TS1005: '=' expected. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,40): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,24): error TS1005: ',' expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,33): error TS1005: '=' expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,40): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts (6 errors) ==== - var foo = async (await): Promise => { ~~~~~ !!! error TS2304: Cannot find name 'async'. diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.js b/tests/baselines/reference/asyncArrowFunction5_es2017.js index 0c61a141f17..b12d06e6e32 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction5_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction5_es2017.ts] - var foo = async (await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt index e19113e66f8..a54794747fa 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,18): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,24): error TS1005: ',' expected. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,33): error TS1005: '=' expected. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,40): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,24): error TS1005: ',' expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,33): error TS1005: '=' expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,40): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts (6 errors) ==== - var foo = async (await): Promise => { ~~~~~ !!! error TS2304: Cannot find name 'async'. diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.js b/tests/baselines/reference/asyncArrowFunction5_es5.js index ff5ee68d4c7..2e15f99e297 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es5.js +++ b/tests/baselines/reference/asyncArrowFunction5_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction5_es5.ts] - var foo = async (await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt index fed29620532..aec8e36fae8 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,18): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,24): error TS1005: ',' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,33): error TS1005: '=' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,40): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,24): error TS1005: ',' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,33): error TS1005: '=' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,40): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts (6 errors) ==== - var foo = async (await): Promise => { ~~~~~ !!! error TS2304: Cannot find name 'async'. diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.js b/tests/baselines/reference/asyncArrowFunction5_es6.js index ed4035e6175..b5ae55a8f48 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es6.js +++ b/tests/baselines/reference/asyncArrowFunction5_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction5_es6.ts] - var foo = async (await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt index 202ecb1727f..9e35d990b1f 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(1,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(1,27): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts (2 errors) ==== - var foo = async (a = await): Promise => { ~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. diff --git a/tests/baselines/reference/asyncArrowFunction6_es2017.js b/tests/baselines/reference/asyncArrowFunction6_es2017.js index c36f75a180a..129460e868b 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction6_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction6_es2017.ts] - var foo = async (a = await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt index a957589bd94..9d0dbd74880 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(1,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(1,27): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts (2 errors) ==== - var foo = async (a = await): Promise => { ~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. diff --git a/tests/baselines/reference/asyncArrowFunction6_es5.js b/tests/baselines/reference/asyncArrowFunction6_es5.js index ea61a1b44b5..fe91930a156 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es5.js +++ b/tests/baselines/reference/asyncArrowFunction6_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction6_es5.ts] - var foo = async (a = await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt index 111e4ff46d0..269fc60962f 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(1,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(1,27): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (2 errors) ==== - var foo = async (a = await): Promise => { ~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index a01e53f5b11..345764a688c 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction6_es6.ts] - var foo = async (a = await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt index 33e03624283..848ceb497f2 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(3,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(3,29): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts (2 errors) ==== - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es2017.js b/tests/baselines/reference/asyncArrowFunction7_es2017.js index 11d8c879eb8..05c78887561 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction7_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction7_es2017.ts] - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt index cc5cf2bb61d..5d4f03cbc41 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(3,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(3,29): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts (2 errors) ==== - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.js b/tests/baselines/reference/asyncArrowFunction7_es5.js index f2edb2b6537..b93966443ab 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es5.js +++ b/tests/baselines/reference/asyncArrowFunction7_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction7_es5.ts] - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt index 6376626d0e7..f37598985c7 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(3,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(3,29): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (2 errors) ==== - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index fab705c0b76..45d9cb3643a 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction7_es6.ts] - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt index 75e460490bd..d5fdfbef24d 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts(3,19): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts(2,19): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts (1 errors) ==== - var foo = async (): Promise => { var v = { [await]: foo } ~ diff --git a/tests/baselines/reference/asyncArrowFunction8_es2017.js b/tests/baselines/reference/asyncArrowFunction8_es2017.js index 1358f186ce2..d5253c8b689 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction8_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction8_es2017.ts] - var foo = async (): Promise => { var v = { [await]: foo } } diff --git a/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt index e2e69fc5bee..620d0b5653b 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts(3,19): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts(2,19): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts (1 errors) ==== - var foo = async (): Promise => { var v = { [await]: foo } ~ diff --git a/tests/baselines/reference/asyncArrowFunction8_es5.js b/tests/baselines/reference/asyncArrowFunction8_es5.js index 30432949262..26153a59436 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es5.js +++ b/tests/baselines/reference/asyncArrowFunction8_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction8_es5.ts] - var foo = async (): Promise => { var v = { [await]: foo } } diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt index 7252805cdca..7105311b06f 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts(3,19): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts(2,19): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts (1 errors) ==== - var foo = async (): Promise => { var v = { [await]: foo } ~ diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js index 0c33cfcfa2d..51ec4318c0a 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.js +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction8_es6.ts] - var foo = async (): Promise => { var v = { [await]: foo } } diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js index 50ecbbb2beb..2afcf5d7dfd 100644 --- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js +++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js @@ -1,5 +1,4 @@ //// [asyncFunctionsAndStrictNullChecks.ts] - declare namespace Windows.Foundation { interface IPromise { then(success?: (value: TResult) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols index 116406f7652..be15e466463 100644 --- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols +++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols @@ -1,136 +1,135 @@ === tests/cases/compiler/asyncFunctionsAndStrictNullChecks.ts === - declare namespace Windows.Foundation { >Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) ->Foundation : Symbol(Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 26)) +>Foundation : Symbol(Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 26)) interface IPromise { ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) then(success?: (value: TResult) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) +>success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 16)) +>value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 27)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 58)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 68)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 95)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 108)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) + + then(success?: (value: TResult) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 58)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 68)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 95)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 108)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 85)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 98)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) - then(success?: (value: TResult) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) + then(success?: (value: TResult) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 48)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 58)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 68)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) >progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 85)) >progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 98)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) - then(success?: (value: TResult) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) + then(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 48)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 58)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 85)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 98)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 75)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 88)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) - then(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) + done(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void): void; +>done : Symbol(IPromise.done, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 125)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 48)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 58)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 75)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 88)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) - - done(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void): void; ->done : Symbol(IPromise.done, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 125)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 13)) ->success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 16)) ->value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 50)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 60)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 79)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 92)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 50)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 60)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 79)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 92)) cancel(): void; ->cancel : Symbol(IPromise.cancel, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 122)) +>cancel : Symbol(IPromise.cancel, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 122)) } } async function sample(promise: Windows.Foundation.IPromise) { ->sample : Symbol(sample, Decl(asyncFunctionsAndStrictNullChecks.ts, 11, 1)) ->promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 13, 22)) +>sample : Symbol(sample, Decl(asyncFunctionsAndStrictNullChecks.ts, 10, 1)) +>promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 12, 22)) >Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) ->Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 26)) ->IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 26)) +>IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) var number = await promise; ->number : Symbol(number, Decl(asyncFunctionsAndStrictNullChecks.ts, 14, 7)) ->promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 13, 22)) +>number : Symbol(number, Decl(asyncFunctionsAndStrictNullChecks.ts, 13, 7)) +>promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 12, 22)) } declare function resolve1(value: T): Promise; ->resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 15, 1)) +>resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 14, 1)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26)) +>value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 29)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26)) + +declare function resolve2(value: T): Windows.Foundation.IPromise; +>resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 51)) >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 29)) >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) ->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) +>Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 26)) +>IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) -declare function resolve2(value: T): Windows.Foundation.IPromise; ->resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 51)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 26)) ->value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 29)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 26)) ->Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) ->Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 26)) ->IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 26)) - async function sample2(x?: number) { ->sample2 : Symbol(sample2, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 71)) ->x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 23)) +>sample2 : Symbol(sample2, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 71)) +>x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 20, 23)) let x1 = await resolve1(x); ->x1 : Symbol(x1, Decl(asyncFunctionsAndStrictNullChecks.ts, 22, 7)) ->resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 15, 1)) ->x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 23)) +>x1 : Symbol(x1, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 7)) +>resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 14, 1)) +>x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 20, 23)) let x2 = await resolve2(x); ->x2 : Symbol(x2, Decl(asyncFunctionsAndStrictNullChecks.ts, 23, 7)) ->resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 51)) ->x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 23)) +>x2 : Symbol(x2, Decl(asyncFunctionsAndStrictNullChecks.ts, 22, 7)) +>resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 51)) +>x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 20, 23)) } diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types index f4eb4f7fa05..bc482898216 100644 --- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types +++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncFunctionsAndStrictNullChecks.ts === - declare namespace Windows.Foundation { >Windows : any >Foundation : any diff --git a/tests/baselines/reference/asyncIIFE.js b/tests/baselines/reference/asyncIIFE.js index 2460dbdf26b..8ca87781113 100644 --- a/tests/baselines/reference/asyncIIFE.js +++ b/tests/baselines/reference/asyncIIFE.js @@ -1,5 +1,4 @@ //// [asyncIIFE.ts] - function f1() { (async () => { await 10 diff --git a/tests/baselines/reference/asyncIIFE.symbols b/tests/baselines/reference/asyncIIFE.symbols index 92eb054bff0..ab7f297379e 100644 --- a/tests/baselines/reference/asyncIIFE.symbols +++ b/tests/baselines/reference/asyncIIFE.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncIIFE.ts === - function f1() { >f1 : Symbol(f1, Decl(asyncIIFE.ts, 0, 0)) @@ -11,6 +10,6 @@ function f1() { })(); var x = 1; ->x : Symbol(x, Decl(asyncIIFE.ts, 7, 7)) +>x : Symbol(x, Decl(asyncIIFE.ts, 6, 7)) } diff --git a/tests/baselines/reference/asyncIIFE.types b/tests/baselines/reference/asyncIIFE.types index e49ab96681f..886c8c3e5ec 100644 --- a/tests/baselines/reference/asyncIIFE.types +++ b/tests/baselines/reference/asyncIIFE.types @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncIIFE.ts === - function f1() { >f1 : () => void diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js index c97fda43011..a3c73c5c1b5 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js @@ -1,5 +1,4 @@ //// [asyncUnParenthesizedArrowFunction_es2017.ts] - declare function someOtherFunction(i: any): Promise; const x = async i => await someOtherFunction(i) const x1 = async (i) => await someOtherFunction(i); diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols index d1de246fa93..45361cfb78e 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es2017.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 35)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 35)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const x = async i => await someOtherFunction(i) ->x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 15)) +>x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 15)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 15)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 15)) const x1 = async (i) => await someOtherFunction(i); ->x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 3, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 3, 18)) +>x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 18)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 3, 18)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 18)) diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types index ff573e29ed3..04c137f81b9 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es2017.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : (i: any) => Promise >i : any diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js index 20b0421d013..93062b6feee 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js @@ -1,5 +1,4 @@ //// [asyncUnParenthesizedArrowFunction_es5.ts] - declare function someOtherFunction(i: any): Promise; const x = async i => await someOtherFunction(i) const x1 = async (i) => await someOtherFunction(i); diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols index 82b73a199ea..c74ecdb8f7a 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es5.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 35)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 35)) >Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) const x = async i => await someOtherFunction(i) ->x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 15)) +>x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 15)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 15)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 15)) const x1 = async (i) => await someOtherFunction(i); ->x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 3, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 3, 18)) +>x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 18)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 3, 18)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 18)) diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types index 745c56cf09b..34ef19e6bd2 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es5.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : (i: any) => Promise >i : any diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js index a4b097a8715..dd5f793ae9d 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js @@ -1,5 +1,4 @@ //// [asyncUnParenthesizedArrowFunction_es6.ts] - declare function someOtherFunction(i: any): Promise; const x = async i => await someOtherFunction(i) const x1 = async (i) => await someOtherFunction(i); diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols index fee86b56cee..26dc2840d2f 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es6.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 35)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 35)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const x = async i => await someOtherFunction(i) ->x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 15)) +>x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 15)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 15)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 15)) const x1 = async (i) => await someOtherFunction(i); ->x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 3, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 3, 18)) +>x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 18)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 3, 18)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 18)) diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types index d2cc97ce6c0..5a0f516c0ea 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es6.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : (i: any) => Promise >i : any diff --git a/tests/baselines/reference/augmentExportEquals1.errors.txt b/tests/baselines/reference/augmentExportEquals1.errors.txt index 2d15e6d622a..fb2429d1c7f 100644 --- a/tests/baselines/reference/augmentExportEquals1.errors.txt +++ b/tests/baselines/reference/augmentExportEquals1.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/file2.ts(6,16): error TS2671: Cannot augment module './file1' because it resolves to a non-module entity. +tests/cases/compiler/file2.ts(5,16): error TS2671: Cannot augment module './file1' because it resolves to a non-module entity. tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. @@ -13,7 +13,6 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. export = x; ==== tests/cases/compiler/file2.ts (1 errors) ==== - import x = require("./file1"); // augmentation for './file1' diff --git a/tests/baselines/reference/augmentExportEquals1.js b/tests/baselines/reference/augmentExportEquals1.js index 7b0bfcf7335..99a6e2e4bb0 100644 --- a/tests/baselines/reference/augmentExportEquals1.js +++ b/tests/baselines/reference/augmentExportEquals1.js @@ -5,7 +5,6 @@ var x = 1; export = x; //// [file2.ts] - import x = require("./file1"); // augmentation for './file1' diff --git a/tests/baselines/reference/augmentExportEquals1_1.errors.txt b/tests/baselines/reference/augmentExportEquals1_1.errors.txt index aa89aa0c1d3..a3d0b28a261 100644 --- a/tests/baselines/reference/augmentExportEquals1_1.errors.txt +++ b/tests/baselines/reference/augmentExportEquals1_1.errors.txt @@ -9,7 +9,6 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. ~ !!! error TS2503: Cannot find namespace 'x'. ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare module "file1" { var x: number; export = x; diff --git a/tests/baselines/reference/augmentExportEquals1_1.js b/tests/baselines/reference/augmentExportEquals1_1.js index 51bc67e7fa4..780043c81ca 100644 --- a/tests/baselines/reference/augmentExportEquals1_1.js +++ b/tests/baselines/reference/augmentExportEquals1_1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals1_1.ts] //// //// [file1.d.ts] - declare module "file1" { var x: number; export = x; diff --git a/tests/baselines/reference/augmentExportEquals2.errors.txt b/tests/baselines/reference/augmentExportEquals2.errors.txt index b078a6623d7..8e1bf70fac4 100644 --- a/tests/baselines/reference/augmentExportEquals2.errors.txt +++ b/tests/baselines/reference/augmentExportEquals2.errors.txt @@ -9,7 +9,6 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. ~ !!! error TS2503: Cannot find namespace 'x'. ==== tests/cases/compiler/file1.ts (0 errors) ==== - function foo() {} export = foo; diff --git a/tests/baselines/reference/augmentExportEquals2.js b/tests/baselines/reference/augmentExportEquals2.js index efdce1bc0cf..8ce1bb90101 100644 --- a/tests/baselines/reference/augmentExportEquals2.js +++ b/tests/baselines/reference/augmentExportEquals2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals2.ts] //// //// [file1.ts] - function foo() {} export = foo; diff --git a/tests/baselines/reference/augmentExportEquals2_1.errors.txt b/tests/baselines/reference/augmentExportEquals2_1.errors.txt index 8e02f21176a..c1e1f2cba9b 100644 --- a/tests/baselines/reference/augmentExportEquals2_1.errors.txt +++ b/tests/baselines/reference/augmentExportEquals2_1.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/file2.ts(6,16): error TS2671: Cannot augment module 'file1' because it resolves to a non-module entity. +tests/cases/compiler/file2.ts(5,16): error TS2671: Cannot augment module 'file1' because it resolves to a non-module entity. tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. @@ -9,14 +9,12 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. ~ !!! error TS2503: Cannot find namespace 'x'. ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare module "file1" { function foo(): void; export = foo; } ==== tests/cases/compiler/file2.ts (1 errors) ==== - /// import x = require("file1"); diff --git a/tests/baselines/reference/augmentExportEquals2_1.js b/tests/baselines/reference/augmentExportEquals2_1.js index 322ab3b36bf..93b76c0259c 100644 --- a/tests/baselines/reference/augmentExportEquals2_1.js +++ b/tests/baselines/reference/augmentExportEquals2_1.js @@ -1,14 +1,12 @@ //// [tests/cases/compiler/augmentExportEquals2_1.ts] //// //// [file1.d.ts] - declare module "file1" { function foo(): void; export = foo; } //// [file2.ts] - /// import x = require("file1"); diff --git a/tests/baselines/reference/augmentExportEquals3.js b/tests/baselines/reference/augmentExportEquals3.js index 387ef86ff79..3ff5f574488 100644 --- a/tests/baselines/reference/augmentExportEquals3.js +++ b/tests/baselines/reference/augmentExportEquals3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals3.ts] //// //// [file1.ts] - function foo() {} namespace foo { export var v = 1; diff --git a/tests/baselines/reference/augmentExportEquals3.symbols b/tests/baselines/reference/augmentExportEquals3.symbols index 485f977321f..06ac04b39f3 100644 --- a/tests/baselines/reference/augmentExportEquals3.symbols +++ b/tests/baselines/reference/augmentExportEquals3.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/file1.ts === - function foo() {} ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 17), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 17), Decl(file2.ts, 1, 8)) namespace foo { ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 17), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 17), Decl(file2.ts, 1, 8)) export var v = 1; ->v : Symbol(v, Decl(file1.ts, 3, 14)) +>v : Symbol(v, Decl(file1.ts, 2, 14)) } export = foo; ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 17)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 17)) === tests/cases/compiler/file2.ts === import x = require("./file1"); diff --git a/tests/baselines/reference/augmentExportEquals3.types b/tests/baselines/reference/augmentExportEquals3.types index f900d59735e..37362bc9649 100644 --- a/tests/baselines/reference/augmentExportEquals3.types +++ b/tests/baselines/reference/augmentExportEquals3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - function foo() {} >foo : typeof foo diff --git a/tests/baselines/reference/augmentExportEquals4.js b/tests/baselines/reference/augmentExportEquals4.js index 37be30731de..3ca522bbc08 100644 --- a/tests/baselines/reference/augmentExportEquals4.js +++ b/tests/baselines/reference/augmentExportEquals4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals4.ts] //// //// [file1.ts] - class foo {} namespace foo { export var v = 1; diff --git a/tests/baselines/reference/augmentExportEquals4.symbols b/tests/baselines/reference/augmentExportEquals4.symbols index 7394e8c6b28..2a4e3dbc147 100644 --- a/tests/baselines/reference/augmentExportEquals4.symbols +++ b/tests/baselines/reference/augmentExportEquals4.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/file1.ts === - class foo {} ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 8)) namespace foo { ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 8)) export var v = 1; ->v : Symbol(v, Decl(file1.ts, 3, 14)) +>v : Symbol(v, Decl(file1.ts, 2, 14)) } export = foo; ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12)) === tests/cases/compiler/file2.ts === import x = require("./file1"); diff --git a/tests/baselines/reference/augmentExportEquals4.types b/tests/baselines/reference/augmentExportEquals4.types index c7ffe8bd774..295156ffb59 100644 --- a/tests/baselines/reference/augmentExportEquals4.types +++ b/tests/baselines/reference/augmentExportEquals4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - class foo {} >foo : foo diff --git a/tests/baselines/reference/augmentExportEquals4_1.js b/tests/baselines/reference/augmentExportEquals4_1.js index 71d39aedb1f..cd2f5459969 100644 --- a/tests/baselines/reference/augmentExportEquals4_1.js +++ b/tests/baselines/reference/augmentExportEquals4_1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals4_1.ts] //// //// [file1.d.ts] - declare module "file1" { class foo {} namespace foo { diff --git a/tests/baselines/reference/augmentExportEquals4_1.symbols b/tests/baselines/reference/augmentExportEquals4_1.symbols index 9954f71bfbc..1488645898c 100644 --- a/tests/baselines/reference/augmentExportEquals4_1.symbols +++ b/tests/baselines/reference/augmentExportEquals4_1.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 2, 8)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 2, 8)) namespace foo { ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 2, 8)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 2, 8)) export var v: number; ->v : Symbol(v, Decl(file1.d.ts, 4, 18)) +>v : Symbol(v, Decl(file1.d.ts, 3, 18)) } export = foo; ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16)) } diff --git a/tests/baselines/reference/augmentExportEquals4_1.types b/tests/baselines/reference/augmentExportEquals4_1.types index 60a7c2d77bb..8eaf1c6cbba 100644 --- a/tests/baselines/reference/augmentExportEquals4_1.types +++ b/tests/baselines/reference/augmentExportEquals4_1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} >foo : foo diff --git a/tests/baselines/reference/augmentExportEquals5.js b/tests/baselines/reference/augmentExportEquals5.js index 7bc5102ca9d..e028b2331da 100644 --- a/tests/baselines/reference/augmentExportEquals5.js +++ b/tests/baselines/reference/augmentExportEquals5.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals5.ts] //// //// [express.d.ts] - - declare module Express { export interface Request { } export interface Response { } diff --git a/tests/baselines/reference/augmentExportEquals5.symbols b/tests/baselines/reference/augmentExportEquals5.symbols index 09da5f32d72..d55e8eed021 100644 --- a/tests/baselines/reference/augmentExportEquals5.symbols +++ b/tests/baselines/reference/augmentExportEquals5.symbols @@ -1,166 +1,164 @@ === tests/cases/compiler/express.d.ts === - - declare module Express { >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) export interface Request { } ->Request : Symbol(Request, Decl(express.d.ts, 2, 24)) +>Request : Symbol(Request, Decl(express.d.ts, 0, 24)) export interface Response { } ->Response : Symbol(Response, Decl(express.d.ts, 3, 32)) +>Response : Symbol(Response, Decl(express.d.ts, 1, 32)) export interface Application { } ->Application : Symbol(Application, Decl(express.d.ts, 4, 33)) +>Application : Symbol(Application, Decl(express.d.ts, 2, 33)) } declare module "express" { function e(): e.Express; ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28), Decl(augmentation.ts, 1, 29)) ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28)) ->Express : Symbol(Express, Decl(express.d.ts, 54, 9)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28), Decl(augmentation.ts, 1, 29)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28)) +>Express : Symbol(Express, Decl(express.d.ts, 52, 9)) namespace e { ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28), Decl(augmentation.ts, 1, 29)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28), Decl(augmentation.ts, 1, 29)) interface IRoute { ->IRoute : Symbol(IRoute, Decl(express.d.ts, 10, 17)) +>IRoute : Symbol(IRoute, Decl(express.d.ts, 8, 17)) all(...handler: RequestHandler[]): IRoute; ->all : Symbol(IRoute.all, Decl(express.d.ts, 11, 26)) ->handler : Symbol(handler, Decl(express.d.ts, 12, 16)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) ->IRoute : Symbol(IRoute, Decl(express.d.ts, 10, 17)) +>all : Symbol(IRoute.all, Decl(express.d.ts, 9, 26)) +>handler : Symbol(handler, Decl(express.d.ts, 10, 16)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) +>IRoute : Symbol(IRoute, Decl(express.d.ts, 8, 17)) } interface IRouterMatcher { ->IRouterMatcher : Symbol(IRouterMatcher, Decl(express.d.ts, 13, 9)) ->T : Symbol(T, Decl(express.d.ts, 15, 33)) +>IRouterMatcher : Symbol(IRouterMatcher, Decl(express.d.ts, 11, 9)) +>T : Symbol(T, Decl(express.d.ts, 13, 33)) (name: string|RegExp, ...handlers: RequestHandler[]): T; ->name : Symbol(name, Decl(express.d.ts, 16, 13)) +>name : Symbol(name, Decl(express.d.ts, 14, 13)) >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->handlers : Symbol(handlers, Decl(express.d.ts, 16, 33)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) ->T : Symbol(T, Decl(express.d.ts, 15, 33)) +>handlers : Symbol(handlers, Decl(express.d.ts, 14, 33)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) +>T : Symbol(T, Decl(express.d.ts, 13, 33)) } interface IRouter extends RequestHandler { ->IRouter : Symbol(IRouter, Decl(express.d.ts, 17, 9)) ->T : Symbol(T, Decl(express.d.ts, 19, 26)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) +>IRouter : Symbol(IRouter, Decl(express.d.ts, 15, 9)) +>T : Symbol(T, Decl(express.d.ts, 17, 26)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) route(path: string): IRoute; ->route : Symbol(IRouter.route, Decl(express.d.ts, 19, 53)) ->path : Symbol(path, Decl(express.d.ts, 20, 18)) ->IRoute : Symbol(IRoute, Decl(express.d.ts, 10, 17)) +>route : Symbol(IRouter.route, Decl(express.d.ts, 17, 53)) +>path : Symbol(path, Decl(express.d.ts, 18, 18)) +>IRoute : Symbol(IRoute, Decl(express.d.ts, 8, 17)) } export function Router(options?: any): Router; ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) ->options : Symbol(options, Decl(express.d.ts, 23, 31)) ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) +>options : Symbol(options, Decl(express.d.ts, 21, 31)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) export interface Router extends IRouter {} ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) ->IRouter : Symbol(IRouter, Decl(express.d.ts, 17, 9)) ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) +>IRouter : Symbol(IRouter, Decl(express.d.ts, 15, 9)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) interface Errback { (err: Error): void; } ->Errback : Symbol(Errback, Decl(express.d.ts, 25, 58)) ->err : Symbol(err, Decl(express.d.ts, 27, 29)) +>Errback : Symbol(Errback, Decl(express.d.ts, 23, 58)) +>err : Symbol(err, Decl(express.d.ts, 25, 29)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) interface Request extends Express.Request { ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->Express.Request : Symbol(Express.Request, Decl(express.d.ts, 2, 24)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>Express.Request : Symbol(Express.Request, Decl(express.d.ts, 0, 24)) >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) ->Request : Symbol(Express.Request, Decl(express.d.ts, 2, 24)) +>Request : Symbol(Express.Request, Decl(express.d.ts, 0, 24)) get (name: string): string; ->get : Symbol(Request.get, Decl(express.d.ts, 29, 51)) ->name : Symbol(name, Decl(express.d.ts, 31, 17)) +>get : Symbol(Request.get, Decl(express.d.ts, 27, 51)) +>name : Symbol(name, Decl(express.d.ts, 29, 17)) } interface Response extends Express.Response { ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->Express.Response : Symbol(Express.Response, Decl(express.d.ts, 3, 32)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>Express.Response : Symbol(Express.Response, Decl(express.d.ts, 1, 32)) >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) ->Response : Symbol(Express.Response, Decl(express.d.ts, 3, 32)) +>Response : Symbol(Express.Response, Decl(express.d.ts, 1, 32)) charset: string; ->charset : Symbol(Response.charset, Decl(express.d.ts, 34, 53)) +>charset : Symbol(Response.charset, Decl(express.d.ts, 32, 53)) } interface ErrorRequestHandler { ->ErrorRequestHandler : Symbol(ErrorRequestHandler, Decl(express.d.ts, 36, 9)) +>ErrorRequestHandler : Symbol(ErrorRequestHandler, Decl(express.d.ts, 34, 9)) (err: any, req: Request, res: Response, next: Function): any; ->err : Symbol(err, Decl(express.d.ts, 39, 13)) ->req : Symbol(req, Decl(express.d.ts, 39, 22)) ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->res : Symbol(res, Decl(express.d.ts, 39, 36)) ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->next : Symbol(next, Decl(express.d.ts, 39, 51)) +>err : Symbol(err, Decl(express.d.ts, 37, 13)) +>req : Symbol(req, Decl(express.d.ts, 37, 22)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>res : Symbol(res, Decl(express.d.ts, 37, 36)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>next : Symbol(next, Decl(express.d.ts, 37, 51)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface RequestHandler { ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) (req: Request, res: Response, next: Function): any; ->req : Symbol(req, Decl(express.d.ts, 43, 13)) ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->res : Symbol(res, Decl(express.d.ts, 43, 26)) ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->next : Symbol(next, Decl(express.d.ts, 43, 41)) +>req : Symbol(req, Decl(express.d.ts, 41, 13)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>res : Symbol(res, Decl(express.d.ts, 41, 26)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>next : Symbol(next, Decl(express.d.ts, 41, 41)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface Handler extends RequestHandler {} ->Handler : Symbol(Handler, Decl(express.d.ts, 44, 9)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) +>Handler : Symbol(Handler, Decl(express.d.ts, 42, 9)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) interface RequestParamHandler { ->RequestParamHandler : Symbol(RequestParamHandler, Decl(express.d.ts, 46, 51)) +>RequestParamHandler : Symbol(RequestParamHandler, Decl(express.d.ts, 44, 51)) (req: Request, res: Response, next: Function, param: any): any; ->req : Symbol(req, Decl(express.d.ts, 49, 13)) ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->res : Symbol(res, Decl(express.d.ts, 49, 26)) ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->next : Symbol(next, Decl(express.d.ts, 49, 41)) +>req : Symbol(req, Decl(express.d.ts, 47, 13)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>res : Symbol(res, Decl(express.d.ts, 47, 26)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>next : Symbol(next, Decl(express.d.ts, 47, 41)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->param : Symbol(param, Decl(express.d.ts, 49, 57)) +>param : Symbol(param, Decl(express.d.ts, 47, 57)) } interface Application extends IRouter, Express.Application { ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) ->IRouter : Symbol(IRouter, Decl(express.d.ts, 17, 9)) ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) ->Express.Application : Symbol(Express.Application, Decl(express.d.ts, 4, 33)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) +>IRouter : Symbol(IRouter, Decl(express.d.ts, 15, 9)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) +>Express.Application : Symbol(Express.Application, Decl(express.d.ts, 2, 33)) >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) ->Application : Symbol(Express.Application, Decl(express.d.ts, 4, 33)) +>Application : Symbol(Express.Application, Decl(express.d.ts, 2, 33)) routes: any; ->routes : Symbol(Application.routes, Decl(express.d.ts, 52, 81)) +>routes : Symbol(Application.routes, Decl(express.d.ts, 50, 81)) } interface Express extends Application { ->Express : Symbol(Express, Decl(express.d.ts, 54, 9)) ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) +>Express : Symbol(Express, Decl(express.d.ts, 52, 9)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) createApplication(): Application; ->createApplication : Symbol(Express.createApplication, Decl(express.d.ts, 56, 47)) ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) +>createApplication : Symbol(Express.createApplication, Decl(express.d.ts, 54, 47)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) } var static: any; ->static : Symbol(static, Decl(express.d.ts, 60, 11)) +>static : Symbol(static, Decl(express.d.ts, 58, 11)) } export = e; ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28)) } === tests/cases/compiler/augmentation.ts === @@ -170,7 +168,7 @@ import * as e from "express"; declare module "express" { interface Request { ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) id: number; >id : Symbol(Request.id, Decl(augmentation.ts, 3, 23)) diff --git a/tests/baselines/reference/augmentExportEquals5.types b/tests/baselines/reference/augmentExportEquals5.types index 7d4d765e5ee..c0444d35358 100644 --- a/tests/baselines/reference/augmentExportEquals5.types +++ b/tests/baselines/reference/augmentExportEquals5.types @@ -1,6 +1,4 @@ === tests/cases/compiler/express.d.ts === - - declare module Express { >Express : any diff --git a/tests/baselines/reference/augmentExportEquals6.js b/tests/baselines/reference/augmentExportEquals6.js index 4299f8653dd..1f6904a4664 100644 --- a/tests/baselines/reference/augmentExportEquals6.js +++ b/tests/baselines/reference/augmentExportEquals6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals6.ts] //// //// [file1.ts] - class foo {} namespace foo { export class A {} diff --git a/tests/baselines/reference/augmentExportEquals6.symbols b/tests/baselines/reference/augmentExportEquals6.symbols index 9ccf8685af7..33ec14ed334 100644 --- a/tests/baselines/reference/augmentExportEquals6.symbols +++ b/tests/baselines/reference/augmentExportEquals6.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/file1.ts === - class foo {} ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 10)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 10)) namespace foo { ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 10)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 10)) export class A {} ->A : Symbol(A, Decl(file1.ts, 2, 15), Decl(file2.ts, 4, 26)) +>A : Symbol(A, Decl(file1.ts, 1, 15), Decl(file2.ts, 4, 26)) export namespace B { export let a; } ->B : Symbol(B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) ->a : Symbol(a, Decl(file1.ts, 4, 35)) +>B : Symbol(B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) +>a : Symbol(a, Decl(file1.ts, 3, 35)) } export = foo; ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12)) === tests/cases/compiler/file2.ts === import x = require("./file1"); @@ -22,19 +21,19 @@ import x = require("./file1"); x.B.b = 1; >x.B.b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) ->x.B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>x.B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >x : Symbol(x, Decl(file2.ts, 0, 0)) ->B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) // OK - './file1' is a namespace declare module "./file1" { interface A { a: number } ->A : Symbol(A, Decl(file1.ts, 2, 15), Decl(file2.ts, 4, 26)) +>A : Symbol(A, Decl(file1.ts, 1, 15), Decl(file2.ts, 4, 26)) >a : Symbol(A.a, Decl(file2.ts, 5, 17)) namespace B { ->B : Symbol(B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>B : Symbol(B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) export let b: number; >b : Symbol(b, Decl(file2.ts, 7, 18)) @@ -49,7 +48,7 @@ import "./file2"; let a: x.A; >a : Symbol(a, Decl(file3.ts, 2, 3)) >x : Symbol(x, Decl(file3.ts, 0, 6)) ->A : Symbol(x.A, Decl(file1.ts, 2, 15), Decl(file2.ts, 4, 26)) +>A : Symbol(x.A, Decl(file1.ts, 1, 15), Decl(file2.ts, 4, 26)) let b = a.a; >b : Symbol(b, Decl(file3.ts, 3, 3)) @@ -60,8 +59,8 @@ let b = a.a; let c = x.B.b; >c : Symbol(c, Decl(file3.ts, 4, 3)) >x.B.b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) ->x.B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>x.B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >x : Symbol(x, Decl(file3.ts, 0, 6)) ->B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) diff --git a/tests/baselines/reference/augmentExportEquals6.types b/tests/baselines/reference/augmentExportEquals6.types index e2342e96dfb..01b7095b169 100644 --- a/tests/baselines/reference/augmentExportEquals6.types +++ b/tests/baselines/reference/augmentExportEquals6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - class foo {} >foo : foo diff --git a/tests/baselines/reference/augmentExportEquals6_1.js b/tests/baselines/reference/augmentExportEquals6_1.js index e69728a766b..d1c7170993b 100644 --- a/tests/baselines/reference/augmentExportEquals6_1.js +++ b/tests/baselines/reference/augmentExportEquals6_1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals6_1.ts] //// //// [file1.d.ts] - declare module "file1" { class foo {} namespace foo { diff --git a/tests/baselines/reference/augmentExportEquals6_1.symbols b/tests/baselines/reference/augmentExportEquals6_1.symbols index c66f01e2d14..60f8b845657 100644 --- a/tests/baselines/reference/augmentExportEquals6_1.symbols +++ b/tests/baselines/reference/augmentExportEquals6_1.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 1, 28)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 1, 28)) namespace foo { ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 1, 28)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 1, 28)) class A {} ->A : Symbol(A, Decl(file1.d.ts, 3, 19), Decl(file2.ts, 4, 24)) +>A : Symbol(A, Decl(file1.d.ts, 2, 19), Decl(file2.ts, 4, 24)) } export = foo; ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16)) } @@ -23,7 +22,7 @@ import x = require("file1"); // OK - './file1' is a namespace declare module "file1" { interface A { a: number } ->A : Symbol(A, Decl(file1.d.ts, 3, 19), Decl(file2.ts, 4, 24)) +>A : Symbol(A, Decl(file1.d.ts, 2, 19), Decl(file2.ts, 4, 24)) >a : Symbol(A.a, Decl(file2.ts, 5, 17)) } @@ -35,7 +34,7 @@ import "file2"; let a: x.A; >a : Symbol(a, Decl(file3.ts, 2, 3)) >x : Symbol(x, Decl(file3.ts, 0, 6)) ->A : Symbol(x.A, Decl(file1.d.ts, 3, 19), Decl(file2.ts, 4, 24)) +>A : Symbol(x.A, Decl(file1.d.ts, 2, 19), Decl(file2.ts, 4, 24)) let b = a.a; >b : Symbol(b, Decl(file3.ts, 3, 3)) diff --git a/tests/baselines/reference/augmentExportEquals6_1.types b/tests/baselines/reference/augmentExportEquals6_1.types index 9d6042ee659..a6041ecda81 100644 --- a/tests/baselines/reference/augmentExportEquals6_1.types +++ b/tests/baselines/reference/augmentExportEquals6_1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} >foo : foo diff --git a/tests/baselines/reference/await_unaryExpression_es2017.js b/tests/baselines/reference/await_unaryExpression_es2017.js index 83fce6588e6..f05bda125fc 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017.js +++ b/tests/baselines/reference/await_unaryExpression_es2017.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017.symbols b/tests/baselines/reference/await_unaryExpression_es2017.symbols index 1aa31031177..51955ac03b7 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017.symbols +++ b/tests/baselines/reference/await_unaryExpression_es2017.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017.ts === - async function bar() { >bar : Symbol(bar, Decl(await_unaryExpression_es2017.ts, 0, 0)) @@ -7,19 +6,19 @@ async function bar() { } async function bar1() { ->bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017.ts, 3, 1)) +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017.ts, 2, 1)) +await 42; // OK } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017.ts, 7, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017.ts, 6, 1)) -await 42; // OK } async function bar4() { ->bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017.ts, 11, 1)) +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017.ts, 10, 1)) ~await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017.types b/tests/baselines/reference/await_unaryExpression_es2017.types index 4f4254df318..5402038cc7b 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017.types +++ b/tests/baselines/reference/await_unaryExpression_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017.ts === - async function bar() { >bar : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt b/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt index afc9ac40f1e..06970ab2856 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(11,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(10,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts (2 errors) ==== - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_1.js b/tests/baselines/reference/await_unaryExpression_es2017_1.js index f863fb19a7e..49a3b34b172 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_1.js +++ b/tests/baselines/reference/await_unaryExpression_es2017_1.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017_1.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt b/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt index e9966847189..e561ceaf79b 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(3,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(2,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts (2 errors) ==== - async function bar1() { delete await 42; ~~~~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es2017_2.js b/tests/baselines/reference/await_unaryExpression_es2017_2.js index b982b20245c..8978e460e7d 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_2.js +++ b/tests/baselines/reference/await_unaryExpression_es2017_2.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017_2.ts] - async function bar1() { delete await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt b/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt index 5d11c4bbb20..da533765a07 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(3,7): error TS1109: Expression expected. -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(7,7): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(2,7): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(6,7): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts (2 errors) ==== - async function bar1() { ++await 42; // Error ~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es2017_3.js b/tests/baselines/reference/await_unaryExpression_es2017_3.js index 5e3c3c3a4bf..b2a1593a9d0 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_3.js +++ b/tests/baselines/reference/await_unaryExpression_es2017_3.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017_3.ts] - async function bar1() { ++await 42; // Error } diff --git a/tests/baselines/reference/await_unaryExpression_es6.js b/tests/baselines/reference/await_unaryExpression_es6.js index f9183f7af3e..1361f80bc8e 100644 --- a/tests/baselines/reference/await_unaryExpression_es6.js +++ b/tests/baselines/reference/await_unaryExpression_es6.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6.symbols b/tests/baselines/reference/await_unaryExpression_es6.symbols index 81edd4b981b..57dfbbc67e3 100644 --- a/tests/baselines/reference/await_unaryExpression_es6.symbols +++ b/tests/baselines/reference/await_unaryExpression_es6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6.ts === - async function bar() { >bar : Symbol(bar, Decl(await_unaryExpression_es6.ts, 0, 0)) @@ -7,19 +6,19 @@ async function bar() { } async function bar1() { ->bar1 : Symbol(bar1, Decl(await_unaryExpression_es6.ts, 3, 1)) +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6.ts, 2, 1)) +await 42; // OK } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es6.ts, 7, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6.ts, 6, 1)) -await 42; // OK } async function bar4() { ->bar4 : Symbol(bar4, Decl(await_unaryExpression_es6.ts, 11, 1)) +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6.ts, 10, 1)) ~await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6.types b/tests/baselines/reference/await_unaryExpression_es6.types index 14b4fbf89ac..15d91936603 100644 --- a/tests/baselines/reference/await_unaryExpression_es6.types +++ b/tests/baselines/reference/await_unaryExpression_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6.ts === - async function bar() { >bar : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt index b4f866ff0ec..9e9d05bf2ab 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(11,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(10,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts (2 errors) ==== - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.js b/tests/baselines/reference/await_unaryExpression_es6_1.js index 948e537cb01..297299e4462 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_1.js +++ b/tests/baselines/reference/await_unaryExpression_es6_1.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6_1.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt index 989e96c7d3f..1c440e84af7 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(3,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(2,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts (2 errors) ==== - async function bar1() { delete await 42; ~~~~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.js b/tests/baselines/reference/await_unaryExpression_es6_2.js index 4b4c1cd6513..fdf83e3def1 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_2.js +++ b/tests/baselines/reference/await_unaryExpression_es6_2.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6_2.ts] - async function bar1() { delete await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt index 5518f84983f..373e6739461 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(3,7): error TS1109: Expression expected. -tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(7,7): error TS1109: Expression expected. +tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(2,7): error TS1109: Expression expected. +tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(6,7): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts (2 errors) ==== - async function bar1() { ++await 42; // Error ~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.js b/tests/baselines/reference/await_unaryExpression_es6_3.js index 6db5d5a7c31..23985832ce1 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_3.js +++ b/tests/baselines/reference/await_unaryExpression_es6_3.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6_3.ts] - async function bar1() { ++await 42; // Error } diff --git a/tests/baselines/reference/bangInModuleName.js b/tests/baselines/reference/bangInModuleName.js index f58827e1ae5..1a6961f59da 100644 --- a/tests/baselines/reference/bangInModuleName.js +++ b/tests/baselines/reference/bangInModuleName.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/bangInModuleName.ts] //// //// [a.d.ts] - - declare module "http" { } @@ -12,7 +10,6 @@ declare module 'intern/dojo/node!http' { } //// [a.ts] - /// import * as http from 'intern/dojo/node!http'; diff --git a/tests/baselines/reference/bangInModuleName.symbols b/tests/baselines/reference/bangInModuleName.symbols index 63ba5d106d8..08bcf487cc8 100644 --- a/tests/baselines/reference/bangInModuleName.symbols +++ b/tests/baselines/reference/bangInModuleName.symbols @@ -1,21 +1,18 @@ === tests/cases/compiler/a.ts === - /// import * as http from 'intern/dojo/node!http'; ->http : Symbol(http, Decl(a.ts, 3, 6)) +>http : Symbol(http, Decl(a.ts, 2, 6)) === tests/cases/compiler/a.d.ts === - - declare module "http" { } declare module 'intern/dojo/node!http' { import http = require('http'); ->http : Symbol(http, Decl(a.d.ts, 5, 40)) +>http : Symbol(http, Decl(a.d.ts, 3, 40)) export = http; ->http : Symbol(http, Decl(a.d.ts, 5, 40)) +>http : Symbol(http, Decl(a.d.ts, 3, 40)) } diff --git a/tests/baselines/reference/bangInModuleName.types b/tests/baselines/reference/bangInModuleName.types index 06a602e2ff8..93115f76a0e 100644 --- a/tests/baselines/reference/bangInModuleName.types +++ b/tests/baselines/reference/bangInModuleName.types @@ -1,13 +1,10 @@ === tests/cases/compiler/a.ts === - /// import * as http from 'intern/dojo/node!http'; >http : typeof http === tests/cases/compiler/a.d.ts === - - declare module "http" { } diff --git a/tests/baselines/reference/bestChoiceType.js b/tests/baselines/reference/bestChoiceType.js index 0c1bf5df2d4..edd36f77be9 100644 --- a/tests/baselines/reference/bestChoiceType.js +++ b/tests/baselines/reference/bestChoiceType.js @@ -1,5 +1,4 @@ //// [bestChoiceType.ts] - // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); diff --git a/tests/baselines/reference/bestChoiceType.symbols b/tests/baselines/reference/bestChoiceType.symbols index 737ba35b520..d5a4d471a15 100644 --- a/tests/baselines/reference/bestChoiceType.symbols +++ b/tests/baselines/reference/bestChoiceType.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/bestChoiceType.ts === - // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); @@ -7,57 +6,57 @@ >''.match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 3, 26)) +>s : Symbol(s, Decl(bestChoiceType.ts, 2, 26)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 3, 26)) +>s : Symbol(s, Decl(bestChoiceType.ts, 2, 26)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) // Similar cases function f1() { ->f1 : Symbol(f1, Decl(bestChoiceType.ts, 3, 48)) +>f1 : Symbol(f1, Decl(bestChoiceType.ts, 2, 48)) let x = ''.match(/ /); ->x : Symbol(x, Decl(bestChoiceType.ts, 8, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 7, 7)) >''.match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) let y = x || []; ->y : Symbol(y, Decl(bestChoiceType.ts, 9, 7)) ->x : Symbol(x, Decl(bestChoiceType.ts, 8, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 8, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 7, 7)) let z = y.map(s => s.toLowerCase()); ->z : Symbol(z, Decl(bestChoiceType.ts, 10, 7)) +>z : Symbol(z, Decl(bestChoiceType.ts, 9, 7)) >y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(bestChoiceType.ts, 9, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 8, 7)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 10, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 9, 18)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 10, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 9, 18)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) } function f2() { ->f2 : Symbol(f2, Decl(bestChoiceType.ts, 11, 1)) +>f2 : Symbol(f2, Decl(bestChoiceType.ts, 10, 1)) let x = ''.match(/ /); ->x : Symbol(x, Decl(bestChoiceType.ts, 14, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 13, 7)) >''.match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) let y = x ? x : []; ->y : Symbol(y, Decl(bestChoiceType.ts, 15, 7)) ->x : Symbol(x, Decl(bestChoiceType.ts, 14, 7)) ->x : Symbol(x, Decl(bestChoiceType.ts, 14, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 14, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 13, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 13, 7)) let z = y.map(s => s.toLowerCase()); ->z : Symbol(z, Decl(bestChoiceType.ts, 16, 7)) +>z : Symbol(z, Decl(bestChoiceType.ts, 15, 7)) >y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(bestChoiceType.ts, 15, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 14, 7)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 16, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 15, 18)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 16, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 15, 18)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types index 07b61fc9f84..17d0595b5a8 100644 --- a/tests/baselines/reference/bestChoiceType.types +++ b/tests/baselines/reference/bestChoiceType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/bestChoiceType.ts === - // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.js b/tests/baselines/reference/bestCommonTypeReturnStatement.js index 6d6f73bc0cf..f4ab98ed1c6 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.js +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.js @@ -1,5 +1,4 @@ //// [bestCommonTypeReturnStatement.ts] - interface IPromise { then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; } diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols index db5fb4cfbcd..8031ffee06f 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/bestCommonTypeReturnStatement.ts === - interface IPromise { >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) ->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19)) +>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19)) then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; ->then : Symbol(IPromise.then, Decl(bestCommonTypeReturnStatement.ts, 1, 23)) ->successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 9)) ->promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 2, 27)) ->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19)) ->errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 51)) ->reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 2, 69)) +>then : Symbol(IPromise.then, Decl(bestCommonTypeReturnStatement.ts, 0, 23)) +>successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 9)) +>promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 1, 27)) +>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19)) +>errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 51)) +>reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 1, 69)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) } function f() { ->f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 3, 1)) +>f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 2, 1)) if (true) return b(); ->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1)) +>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1)) return d(); ->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45)) +>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45)) } function b(): IPromise { return null; } ->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1)) +>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) function d(): IPromise { return null; } ->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45)) +>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.types b/tests/baselines/reference/bestCommonTypeReturnStatement.types index b327e707350..3cc3a221212 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.types +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.types @@ -1,5 +1,4 @@ === tests/cases/compiler/bestCommonTypeReturnStatement.ts === - interface IPromise { >IPromise : IPromise >T : T diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt index c3e9f220a3a..411c7099f11 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt +++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(35,24): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(36,24): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(34,24): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(35,24): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(46,26): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(46,33): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,26): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,33): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,33): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,26): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,38): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,33): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,38): error TS2532: Object is possibly 'undefined'. ==== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts (8 errors) ==== - // ~ operator on any type var ANY: any; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js index 860dbc68a53..0236bd736ee 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithAnyOtherType.ts] - // ~ operator on any type var ANY: any; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js index cd0e967b66f..b35a5e4ba12 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithBooleanType.ts] - // ~ operator on boolean type var BOOLEAN: boolean; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols index ad30b16dd08..d52e73ba600 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols @@ -1,90 +1,89 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithBooleanType.ts === - // ~ operator on boolean type var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) function foo(): boolean { return true; } ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 21)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 21)) class A { ->A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 4, 40)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 3, 40)) public a: boolean; ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) static foo() { return false; } ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 7, 22)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 22)) } module M { ->M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 9, 1)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 8, 1)) export var n: boolean; ->n : Symbol(n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 14, 3)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 4, 40)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 13, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 3, 40)) // boolean type var var ResultIsNumber1 = ~BOOLEAN; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithBooleanType.ts, 17, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithBooleanType.ts, 16, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) // boolean type literal var ResultIsNumber2 = ~true; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithBooleanType.ts, 19, 3)) var ResultIsNumber3 = ~{ x: true, y: false }; ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithBooleanType.ts, 21, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithBooleanType.ts, 21, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithBooleanType.ts, 21, 33)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 33)) // boolean type expressions var ResultIsNumber4 = ~objA.a; ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithBooleanType.ts, 24, 3)) ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 14, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithBooleanType.ts, 23, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 13, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) var ResultIsNumber5 = ~M.n; ->ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithBooleanType.ts, 25, 3)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 9, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithBooleanType.ts, 24, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 8, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) var ResultIsNumber6 = ~foo(); ->ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithBooleanType.ts, 26, 3)) ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 21)) +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithBooleanType.ts, 25, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 21)) var ResultIsNumber7 = ~A.foo(); ->ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithBooleanType.ts, 27, 3)) ->A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 7, 22)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 4, 40)) ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 7, 22)) +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithBooleanType.ts, 26, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 22)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 3, 40)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 22)) // multiple ~ operators var ResultIsNumber8 = ~~BOOLEAN; ->ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithBooleanType.ts, 30, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithBooleanType.ts, 29, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) // miss assignment operators ~true; ~BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) ~foo(); ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 21)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 21)) ~true, false; ~objA.a; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 14, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 13, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) ~M.n; ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 9, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 8, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types index ccdc6a7bf0c..2875a46355c 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithBooleanType.ts === - // ~ operator on boolean type var BOOLEAN: boolean; >BOOLEAN : boolean diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js index a270fc98c51..0bcf2fa3956 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithEnumType.ts] - // ~ operator on enum type enum ENUM1 { A, B, "" }; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols index 6bd0aa8ad55..24783a153ae 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols @@ -1,39 +1,38 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts === - // ~ operator on enum type enum ENUM1 { A, B, "" }; >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) ->B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) +>B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) // enum type var var ResultIsNumber1 = ~ENUM1; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithEnumType.ts, 6, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithEnumType.ts, 5, 3)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) // enum type expressions var ResultIsNumber2 = ~ENUM1["A"]; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithEnumType.ts, 9, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithEnumType.ts, 8, 3)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) var ResultIsNumber3 = ~(ENUM1.A + ENUM1["B"]); ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithEnumType.ts, 10, 3)) ->ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithEnumType.ts, 9, 3)) +>ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) // multiple ~ operators var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B); ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithEnumType.ts, 13, 3)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithEnumType.ts, 12, 3)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) ->ENUM1.B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) +>ENUM1.B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) // miss assignment operators ~ENUM1; @@ -41,12 +40,12 @@ var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B); ~ENUM1["A"]; >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) ~ENUM1.A, ~ENUM1["B"]; ->ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types index 53d44f584ea..03008f67d11 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts === - // ~ operator on enum type enum ENUM1 { A, B, "" }; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js index b6660f677c7..aab04be6dfc 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithNumberType.ts] - // ~ operator on number type var NUMBER: number; var NUMBER1: number[] = [1, 2]; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols index 8ce159b9171..f7dd03d78c3 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols @@ -1,127 +1,126 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithNumberType.ts === - // ~ operator on number type var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) var NUMBER1: number[] = [1, 2]; ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) function foo(): number { return 1; } ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 31)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 31)) class A { ->A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 5, 36)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 4, 36)) public a: number; ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) static foo() { return 1; } ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 8, 21)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 21)) } module M { ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) export var n: number; ->n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 5, 36)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 4, 36)) // number type var var ResultIsNumber1 = ~NUMBER; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithNumberType.ts, 18, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithNumberType.ts, 17, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) var ResultIsNumber2 = ~NUMBER1; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithNumberType.ts, 19, 3)) ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithNumberType.ts, 18, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) // number type literal var ResultIsNumber3 = ~1; ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 3)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithNumberType.ts, 21, 3)) var ResultIsNumber4 = ~{ x: 1, y: 2}; ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 30)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 30)) var ResultIsNumber5 = ~{ x: 1, y: (n: number) => { return n; } }; ->ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 30)) ->n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 35)) ->n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 35)) +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 30)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35)) // number type expressions var ResultIsNumber6 = ~objA.a; ->ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithNumberType.ts, 27, 3)) ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithNumberType.ts, 26, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) var ResultIsNumber7 = ~M.n; ->ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithNumberType.ts, 28, 3)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithNumberType.ts, 27, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) var ResultIsNumber8 = ~NUMBER1[0]; ->ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithNumberType.ts, 29, 3)) ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithNumberType.ts, 28, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) var ResultIsNumber9 = ~foo(); ->ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithNumberType.ts, 30, 3)) ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 31)) +>ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithNumberType.ts, 29, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 31)) var ResultIsNumber10 = ~A.foo(); ->ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithNumberType.ts, 31, 3)) ->A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 8, 21)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 5, 36)) ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 8, 21)) +>ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithNumberType.ts, 30, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 21)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 4, 36)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 21)) var ResultIsNumber11 = ~(NUMBER + NUMBER); ->ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithNumberType.ts, 32, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithNumberType.ts, 31, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) // multiple ~ operators var ResultIsNumber12 = ~~NUMBER; ->ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithNumberType.ts, 35, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithNumberType.ts, 34, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) var ResultIsNumber13 = ~~~(NUMBER + NUMBER); ->ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithNumberType.ts, 36, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithNumberType.ts, 35, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) // miss assignment operators ~NUMBER; ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) ~NUMBER1; ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) ~foo(); ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 31)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 31)) ~objA.a; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) ~M.n; ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) ~objA.a, M.n; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types index 880ef82b953..8dc3c31867f 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithNumberType.ts === - // ~ operator on number type var NUMBER: number; >NUMBER : number diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.js b/tests/baselines/reference/bitwiseNotOperatorWithStringType.js index b1c3b41f286..366af5ecea8 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithStringType.ts] - // ~ operator on string type var STRING: string; var STRING1: string[] = ["", "abc"]; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols index 06f848c7450..f535acc199b 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols @@ -1,123 +1,122 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithStringType.ts === - // ~ operator on string type var STRING: string; ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var STRING1: string[] = ["", "abc"]; ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) function foo(): string { return "abc"; } ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 3, 36)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 2, 36)) class A { ->A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 5, 40)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 4, 40)) public a: string; ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) static foo() { return ""; } ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 8, 21)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 7, 21)) } module M { ->M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 10, 1)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 9, 1)) export var n: string; ->n : Symbol(n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 15, 3)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 5, 40)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 14, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 4, 40)) // string type var var ResultIsNumber1 = ~STRING; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithStringType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithStringType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var ResultIsNumber2 = ~STRING1; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithStringType.ts, 19, 3)) ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithStringType.ts, 18, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) // string type literal var ResultIsNumber3 = ~""; ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithStringType.ts, 22, 3)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithStringType.ts, 21, 3)) var ResultIsNumber4 = ~{ x: "", y: "" }; ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithStringType.ts, 23, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 23, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 23, 31)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithStringType.ts, 22, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 22, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 22, 31)) var ResultIsNumber5 = ~{ x: "", y: (s: string) => { return s; } }; ->ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithStringType.ts, 24, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 24, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 24, 31)) ->s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 24, 36)) ->s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 24, 36)) +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithStringType.ts, 23, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 23, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 23, 31)) +>s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36)) +>s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36)) // string type expressions var ResultIsNumber6 = ~objA.a; ->ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithStringType.ts, 27, 3)) ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithStringType.ts, 26, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) var ResultIsNumber7 = ~M.n; ->ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithStringType.ts, 28, 3)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithStringType.ts, 27, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) var ResultIsNumber8 = ~STRING1[0]; ->ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithStringType.ts, 29, 3)) ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithStringType.ts, 28, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) var ResultIsNumber9 = ~foo(); ->ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithStringType.ts, 30, 3)) ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 3, 36)) +>ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithStringType.ts, 29, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 2, 36)) var ResultIsNumber10 = ~A.foo(); ->ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithStringType.ts, 31, 3)) ->A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 8, 21)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 5, 40)) ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 8, 21)) +>ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithStringType.ts, 30, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 7, 21)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 4, 40)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 7, 21)) var ResultIsNumber11 = ~(STRING + STRING); ->ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithStringType.ts, 32, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithStringType.ts, 31, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var ResultIsNumber12 = ~STRING.charAt(0); ->ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithStringType.ts, 33, 3)) +>ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithStringType.ts, 32, 3)) >STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple ~ operators var ResultIsNumber13 = ~~STRING; ->ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithStringType.ts, 36, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithStringType.ts, 35, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var ResultIsNumber14 = ~~~(STRING + STRING); ->ResultIsNumber14 : Symbol(ResultIsNumber14, Decl(bitwiseNotOperatorWithStringType.ts, 37, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber14 : Symbol(ResultIsNumber14, Decl(bitwiseNotOperatorWithStringType.ts, 36, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) //miss assignment operators ~STRING; ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) ~STRING1; ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) ~foo(); ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 3, 36)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 2, 36)) ~objA.a,M.n; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.types b/tests/baselines/reference/bitwiseNotOperatorWithStringType.types index 17a7fc8b6ec..130b52c8471 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithStringType.ts === - // ~ operator on string type var STRING: string; >STRING : string diff --git a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js index d299aaa8452..60ecfad3bc9 100644 --- a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js +++ b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js @@ -1,5 +1,4 @@ //// [blockScopedBindingsReassignedInLoop3.ts] - for (let x = 1, y = 2; x < y; ++x, --y) { let a = () => x++ + y++; if (x == 1) { diff --git a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols index f78cd684c3a..71e251f2dc3 100644 --- a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols +++ b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols @@ -1,203 +1,202 @@ === tests/cases/compiler/blockScopedBindingsReassignedInLoop3.ts === - for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 2, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) break; } else { for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 8, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) break; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) } } for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 24, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) continue; } else { for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 30, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) continue; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) } } loop2: for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 46, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) break loop2; } else { loop1: for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 53, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) break loop1; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) break loop2 } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) } } loop2: for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 70, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) continue loop2; } else { loop1: for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 77, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) continue loop1; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) continue loop2 } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) } } diff --git a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types index 3dab1458b67..a61137b3e3a 100644 --- a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types +++ b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/blockScopedBindingsReassignedInLoop3.ts === - for (let x = 1, y = 2; x < y; ++x, --y) { >x : number >1 : 1 diff --git a/tests/baselines/reference/booleanLiteralTypes2.js b/tests/baselines/reference/booleanLiteralTypes2.js index 7ef643593a6..19bac7c362c 100644 --- a/tests/baselines/reference/booleanLiteralTypes2.js +++ b/tests/baselines/reference/booleanLiteralTypes2.js @@ -1,5 +1,4 @@ //// [booleanLiteralTypes2.ts] - type A1 = true | false; type A2 = false | true; diff --git a/tests/baselines/reference/booleanLiteralTypes2.symbols b/tests/baselines/reference/booleanLiteralTypes2.symbols index 1f64767cbb4..ad3e90ad3f8 100644 --- a/tests/baselines/reference/booleanLiteralTypes2.symbols +++ b/tests/baselines/reference/booleanLiteralTypes2.symbols @@ -1,141 +1,140 @@ === tests/cases/conformance/types/literal/booleanLiteralTypes2.ts === - type A1 = true | false; >A1 : Symbol(A1, Decl(booleanLiteralTypes2.ts, 0, 0)) type A2 = false | true; ->A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 1, 23)) +>A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 0, 23)) function f1() { ->f1 : Symbol(f1, Decl(booleanLiteralTypes2.ts, 2, 23)) +>f1 : Symbol(f1, Decl(booleanLiteralTypes2.ts, 1, 23)) var a: A1; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) >A1 : Symbol(A1, Decl(booleanLiteralTypes2.ts, 0, 0)) var a: A2; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) ->A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 1, 23)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) +>A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 0, 23)) var a: true | false; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) var a: false | true; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) } function f2(a: true | false, b: boolean) { ->f2 : Symbol(f2, Decl(booleanLiteralTypes2.ts, 9, 1)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 11, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 11, 28)) +>f2 : Symbol(f2, Decl(booleanLiteralTypes2.ts, 8, 1)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 10, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 10, 28)) a = b; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 11, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 11, 28)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 10, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 10, 28)) b = a; ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 11, 28)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 11, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 10, 28)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 10, 12)) } function f3(a: true | false, b: true | false) { ->f3 : Symbol(f3, Decl(booleanLiteralTypes2.ts, 14, 1)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 16, 28)) +>f3 : Symbol(f3, Decl(booleanLiteralTypes2.ts, 13, 1)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 15, 28)) var x = a || b; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7), Decl(booleanLiteralTypes2.ts, 19, 7)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 16, 28)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 16, 7), Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 15, 28)) var x = a && b; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7), Decl(booleanLiteralTypes2.ts, 19, 7)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 16, 28)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 16, 7), Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 15, 28)) var x = !a; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7), Decl(booleanLiteralTypes2.ts, 19, 7)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 16, 7), Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) } function f4(t: true, f: false) { ->f4 : Symbol(f4, Decl(booleanLiteralTypes2.ts, 20, 1)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>f4 : Symbol(f4, Decl(booleanLiteralTypes2.ts, 19, 1)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) var x1 = t && f; ->x1 : Symbol(x1, Decl(booleanLiteralTypes2.ts, 23, 7)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>x1 : Symbol(x1, Decl(booleanLiteralTypes2.ts, 22, 7)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) var x2 = f && t; ->x2 : Symbol(x2, Decl(booleanLiteralTypes2.ts, 24, 7)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) +>x2 : Symbol(x2, Decl(booleanLiteralTypes2.ts, 23, 7)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) var x3 = t || f; ->x3 : Symbol(x3, Decl(booleanLiteralTypes2.ts, 25, 7)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>x3 : Symbol(x3, Decl(booleanLiteralTypes2.ts, 24, 7)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) var x4 = f || t; ->x4 : Symbol(x4, Decl(booleanLiteralTypes2.ts, 26, 7)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) +>x4 : Symbol(x4, Decl(booleanLiteralTypes2.ts, 25, 7)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) var x5 = !t; ->x5 : Symbol(x5, Decl(booleanLiteralTypes2.ts, 27, 7)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) +>x5 : Symbol(x5, Decl(booleanLiteralTypes2.ts, 26, 7)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) var x6 = !f; ->x6 : Symbol(x6, Decl(booleanLiteralTypes2.ts, 28, 7)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>x6 : Symbol(x6, Decl(booleanLiteralTypes2.ts, 27, 7)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) } declare function g(x: true): string; ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 31, 19)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 30, 19)) declare function g(x: false): boolean; ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 32, 19)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 31, 19)) declare function g(x: boolean): number; ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 33, 19)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 32, 19)) function f5(b: boolean) { ->f5 : Symbol(f5, Decl(booleanLiteralTypes2.ts, 33, 39)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 35, 12)) +>f5 : Symbol(f5, Decl(booleanLiteralTypes2.ts, 32, 39)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 34, 12)) var z1 = g(true); ->z1 : Symbol(z1, Decl(booleanLiteralTypes2.ts, 36, 7)) ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) +>z1 : Symbol(z1, Decl(booleanLiteralTypes2.ts, 35, 7)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) var z2 = g(false); ->z2 : Symbol(z2, Decl(booleanLiteralTypes2.ts, 37, 7)) ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) +>z2 : Symbol(z2, Decl(booleanLiteralTypes2.ts, 36, 7)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) var z3 = g(b); ->z3 : Symbol(z3, Decl(booleanLiteralTypes2.ts, 38, 7)) ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 35, 12)) +>z3 : Symbol(z3, Decl(booleanLiteralTypes2.ts, 37, 7)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 34, 12)) } function assertNever(x: never): never { ->assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 39, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 41, 21)) +>assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 38, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 40, 21)) throw new Error("Unexpected value"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f10(x: true | false) { ->f10 : Symbol(f10, Decl(booleanLiteralTypes2.ts, 43, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 45, 13)) +>f10 : Symbol(f10, Decl(booleanLiteralTypes2.ts, 42, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 44, 13)) switch (x) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 45, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 44, 13)) case true: return "true"; case false: return "false"; @@ -143,106 +142,106 @@ function f10(x: true | false) { } function f11(x: true | false) { ->f11 : Symbol(f11, Decl(booleanLiteralTypes2.ts, 50, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 52, 13)) +>f11 : Symbol(f11, Decl(booleanLiteralTypes2.ts, 49, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 51, 13)) switch (x) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 52, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 51, 13)) case true: return "true"; case false: return "false"; } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 39, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 52, 13)) +>assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 38, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 51, 13)) } function f12(x: true | false) { ->f12 : Symbol(f12, Decl(booleanLiteralTypes2.ts, 58, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>f12 : Symbol(f12, Decl(booleanLiteralTypes2.ts, 57, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) if (x) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) } else { x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) } } function f13(x: true | false) { ->f13 : Symbol(f13, Decl(booleanLiteralTypes2.ts, 67, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>f13 : Symbol(f13, Decl(booleanLiteralTypes2.ts, 66, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) if (x === true) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) } else { x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) } } type Item = ->Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 76, 1)) +>Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 75, 1)) { kind: true, a: string } | ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) { kind: false, b: string }; ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 80, 5)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) function f20(x: Item) { ->f20 : Symbol(f20, Decl(booleanLiteralTypes2.ts, 80, 31)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 76, 1)) +>f20 : Symbol(f20, Decl(booleanLiteralTypes2.ts, 79, 31)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 75, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) +>x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) case true: return x.a; ->x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) +>x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) case false: return x.b; ->x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) +>x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) } } function f21(x: Item) { ->f21 : Symbol(f21, Decl(booleanLiteralTypes2.ts, 87, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 76, 1)) +>f21 : Symbol(f21, Decl(booleanLiteralTypes2.ts, 86, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 75, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) +>x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) case true: return x.a; ->x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) +>x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) case false: return x.b; ->x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) +>x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 39, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) +>assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 38, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) } diff --git a/tests/baselines/reference/booleanLiteralTypes2.types b/tests/baselines/reference/booleanLiteralTypes2.types index e5e4fba7f4f..8c0116407cc 100644 --- a/tests/baselines/reference/booleanLiteralTypes2.types +++ b/tests/baselines/reference/booleanLiteralTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/booleanLiteralTypes2.ts === - type A1 = true | false; >A1 : boolean >true : true diff --git a/tests/baselines/reference/breakTarget3.js b/tests/baselines/reference/breakTarget3.js index b36eeb3902b..0fa6cd2d298 100644 --- a/tests/baselines/reference/breakTarget3.js +++ b/tests/baselines/reference/breakTarget3.js @@ -1,5 +1,4 @@ //// [breakTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/breakTarget3.symbols b/tests/baselines/reference/breakTarget3.symbols index a0b17435504..580706bbd4a 100644 --- a/tests/baselines/reference/breakTarget3.symbols +++ b/tests/baselines/reference/breakTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/breakTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target1; diff --git a/tests/baselines/reference/breakTarget3.types b/tests/baselines/reference/breakTarget3.types index 6e926768e12..83065c8929b 100644 --- a/tests/baselines/reference/breakTarget3.types +++ b/tests/baselines/reference/breakTarget3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/breakTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/breakTarget4.js b/tests/baselines/reference/breakTarget4.js index 0c91e44ecbd..4586301d71b 100644 --- a/tests/baselines/reference/breakTarget4.js +++ b/tests/baselines/reference/breakTarget4.js @@ -1,5 +1,4 @@ //// [breakTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/breakTarget4.symbols b/tests/baselines/reference/breakTarget4.symbols index d4edcb17e1a..aba35ddcfdf 100644 --- a/tests/baselines/reference/breakTarget4.symbols +++ b/tests/baselines/reference/breakTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/breakTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target2; diff --git a/tests/baselines/reference/breakTarget4.types b/tests/baselines/reference/breakTarget4.types index 80bee56f9c7..d183879a47b 100644 --- a/tests/baselines/reference/breakTarget4.types +++ b/tests/baselines/reference/breakTarget4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/breakTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/breakTarget5.errors.txt b/tests/baselines/reference/breakTarget5.errors.txt index d92f29d67ee..a54a415b990 100644 --- a/tests/baselines/reference/breakTarget5.errors.txt +++ b/tests/baselines/reference/breakTarget5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/breakTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/breakTarget5.ts (1 errors) ==== - target: while (true) { function f() { diff --git a/tests/baselines/reference/breakTarget5.js b/tests/baselines/reference/breakTarget5.js index 9f6b063a8c4..197e4e147bd 100644 --- a/tests/baselines/reference/breakTarget5.js +++ b/tests/baselines/reference/breakTarget5.js @@ -1,5 +1,4 @@ //// [breakTarget5.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/cacheResolutions.js b/tests/baselines/reference/cacheResolutions.js index 6b28c90e321..8c986c8fa14 100644 --- a/tests/baselines/reference/cacheResolutions.js +++ b/tests/baselines/reference/cacheResolutions.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cacheResolutions.ts] //// //// [app.ts] - export let x = 1; //// [lib1.ts] diff --git a/tests/baselines/reference/cacheResolutions.symbols b/tests/baselines/reference/cacheResolutions.symbols index 362ce5c308c..4b40798149b 100644 --- a/tests/baselines/reference/cacheResolutions.symbols +++ b/tests/baselines/reference/cacheResolutions.symbols @@ -1,7 +1,6 @@ === /a/b/c/app.ts === - export let x = 1; ->x : Symbol(x, Decl(app.ts, 1, 10)) +>x : Symbol(x, Decl(app.ts, 0, 10)) === /a/b/c/lib1.ts === export let x = 1; diff --git a/tests/baselines/reference/cacheResolutions.types b/tests/baselines/reference/cacheResolutions.types index fdcc0a6c46c..59d208b5d22 100644 --- a/tests/baselines/reference/cacheResolutions.types +++ b/tests/baselines/reference/cacheResolutions.types @@ -1,5 +1,4 @@ === /a/b/c/app.ts === - export let x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/cachedModuleResolution1.js b/tests/baselines/reference/cachedModuleResolution1.js index d93133cca40..cd83308f922 100644 --- a/tests/baselines/reference/cachedModuleResolution1.js +++ b/tests/baselines/reference/cachedModuleResolution1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution1.ts] //// //// [foo.d.ts] - export declare let x: number //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution1.symbols b/tests/baselines/reference/cachedModuleResolution1.symbols index f7d3c474a56..87685f4f147 100644 --- a/tests/baselines/reference/cachedModuleResolution1.symbols +++ b/tests/baselines/reference/cachedModuleResolution1.symbols @@ -1,7 +1,6 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/d/e/app.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution1.types b/tests/baselines/reference/cachedModuleResolution1.types index c041e8cc340..ccc9e1311c8 100644 --- a/tests/baselines/reference/cachedModuleResolution1.types +++ b/tests/baselines/reference/cachedModuleResolution1.types @@ -1,5 +1,4 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution2.js b/tests/baselines/reference/cachedModuleResolution2.js index c5c3357f65a..8ecb42a32ae 100644 --- a/tests/baselines/reference/cachedModuleResolution2.js +++ b/tests/baselines/reference/cachedModuleResolution2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution2.ts] //// //// [foo.d.ts] - export declare let x: number //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution2.symbols b/tests/baselines/reference/cachedModuleResolution2.symbols index c8356eadb11..b9080b03cbf 100644 --- a/tests/baselines/reference/cachedModuleResolution2.symbols +++ b/tests/baselines/reference/cachedModuleResolution2.symbols @@ -1,7 +1,6 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/lib.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution2.types b/tests/baselines/reference/cachedModuleResolution2.types index c5069e681c4..4c34d48b3a9 100644 --- a/tests/baselines/reference/cachedModuleResolution2.types +++ b/tests/baselines/reference/cachedModuleResolution2.types @@ -1,5 +1,4 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution3.js b/tests/baselines/reference/cachedModuleResolution3.js index d476eafd2e8..f5da6940099 100644 --- a/tests/baselines/reference/cachedModuleResolution3.js +++ b/tests/baselines/reference/cachedModuleResolution3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution3.ts] //// //// [foo.d.ts] - export declare let x: number //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution3.symbols b/tests/baselines/reference/cachedModuleResolution3.symbols index 799ac6d8d84..3c5e12431c0 100644 --- a/tests/baselines/reference/cachedModuleResolution3.symbols +++ b/tests/baselines/reference/cachedModuleResolution3.symbols @@ -1,7 +1,6 @@ === /a/b/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/d/e/app.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution3.types b/tests/baselines/reference/cachedModuleResolution3.types index f87abf1519e..412ef2ae1d5 100644 --- a/tests/baselines/reference/cachedModuleResolution3.types +++ b/tests/baselines/reference/cachedModuleResolution3.types @@ -1,5 +1,4 @@ === /a/b/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution4.js b/tests/baselines/reference/cachedModuleResolution4.js index 4cc656d73d3..f5417960d46 100644 --- a/tests/baselines/reference/cachedModuleResolution4.js +++ b/tests/baselines/reference/cachedModuleResolution4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution4.ts] //// //// [foo.d.ts] - export declare let x: number //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution4.symbols b/tests/baselines/reference/cachedModuleResolution4.symbols index a30e6bf74e5..a145a182036 100644 --- a/tests/baselines/reference/cachedModuleResolution4.symbols +++ b/tests/baselines/reference/cachedModuleResolution4.symbols @@ -1,7 +1,6 @@ === /a/b/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/lib.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution4.types b/tests/baselines/reference/cachedModuleResolution4.types index 3689e57ca6d..ca4050e655d 100644 --- a/tests/baselines/reference/cachedModuleResolution4.types +++ b/tests/baselines/reference/cachedModuleResolution4.types @@ -1,5 +1,4 @@ === /a/b/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution5.js b/tests/baselines/reference/cachedModuleResolution5.js index 35fad11d90e..4fe641e917e 100644 --- a/tests/baselines/reference/cachedModuleResolution5.js +++ b/tests/baselines/reference/cachedModuleResolution5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution5.ts] //// //// [foo.d.ts] - export declare let x: number //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution5.symbols b/tests/baselines/reference/cachedModuleResolution5.symbols index eb72f0c7a27..6c18677efcf 100644 --- a/tests/baselines/reference/cachedModuleResolution5.symbols +++ b/tests/baselines/reference/cachedModuleResolution5.symbols @@ -1,7 +1,6 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/d/e/app.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution5.types b/tests/baselines/reference/cachedModuleResolution5.types index ad2640402f7..e827caaf922 100644 --- a/tests/baselines/reference/cachedModuleResolution5.types +++ b/tests/baselines/reference/cachedModuleResolution5.types @@ -1,5 +1,4 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution6.errors.txt b/tests/baselines/reference/cachedModuleResolution6.errors.txt index b272ff29b9d..7d79a200e11 100644 --- a/tests/baselines/reference/cachedModuleResolution6.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution6.errors.txt @@ -1,9 +1,8 @@ -/a/b/c/d/e/app.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. /a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/d/e/app.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution6.js b/tests/baselines/reference/cachedModuleResolution6.js index 1e6803b115c..364ad55aa6c 100644 --- a/tests/baselines/reference/cachedModuleResolution6.js +++ b/tests/baselines/reference/cachedModuleResolution6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution6.ts] //// //// [app.ts] - import {x} from "foo"; //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution7.errors.txt b/tests/baselines/reference/cachedModuleResolution7.errors.txt index 670c4a665a6..9bc6e3f239c 100644 --- a/tests/baselines/reference/cachedModuleResolution7.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution7.errors.txt @@ -1,9 +1,8 @@ /a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. -/a/b/c/lib.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/lib.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution7.js b/tests/baselines/reference/cachedModuleResolution7.js index 044eefff73a..9b103fdd9bf 100644 --- a/tests/baselines/reference/cachedModuleResolution7.js +++ b/tests/baselines/reference/cachedModuleResolution7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution7.ts] //// //// [lib.ts] - import {x} from "foo"; //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution8.errors.txt b/tests/baselines/reference/cachedModuleResolution8.errors.txt index b272ff29b9d..7d79a200e11 100644 --- a/tests/baselines/reference/cachedModuleResolution8.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution8.errors.txt @@ -1,9 +1,8 @@ -/a/b/c/d/e/app.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. /a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/d/e/app.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution8.js b/tests/baselines/reference/cachedModuleResolution8.js index fe89a8f288f..9e8b67fabf7 100644 --- a/tests/baselines/reference/cachedModuleResolution8.js +++ b/tests/baselines/reference/cachedModuleResolution8.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution8.ts] //// //// [app.ts] - import {x} from "foo"; //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution9.errors.txt b/tests/baselines/reference/cachedModuleResolution9.errors.txt index aeec41f0048..482a34cb654 100644 --- a/tests/baselines/reference/cachedModuleResolution9.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution9.errors.txt @@ -1,9 +1,8 @@ /a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. -/a/b/c/lib.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/lib.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution9.js b/tests/baselines/reference/cachedModuleResolution9.js index c27ababcb95..8de0a1ff173 100644 --- a/tests/baselines/reference/cachedModuleResolution9.js +++ b/tests/baselines/reference/cachedModuleResolution9.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution9.ts] //// //// [lib.ts] - import {x} from "foo"; diff --git a/tests/baselines/reference/callConstructAssignment.errors.txt b/tests/baselines/reference/callConstructAssignment.errors.txt index 62a529daeb1..904d4947a34 100644 --- a/tests/baselines/reference/callConstructAssignment.errors.txt +++ b/tests/baselines/reference/callConstructAssignment.errors.txt @@ -1,12 +1,10 @@ -tests/cases/compiler/callConstructAssignment.ts(7,1): error TS2322: Type 'new () => any' is not assignable to type '() => void'. +tests/cases/compiler/callConstructAssignment.ts(5,1): error TS2322: Type 'new () => any' is not assignable to type '() => void'. Type 'new () => any' provides no match for the signature '(): void'. -tests/cases/compiler/callConstructAssignment.ts(8,1): error TS2322: Type '() => void' is not assignable to type 'new () => any'. +tests/cases/compiler/callConstructAssignment.ts(6,1): error TS2322: Type '() => void' is not assignable to type 'new () => any'. Type '() => void' provides no match for the signature 'new (): any'. ==== tests/cases/compiler/callConstructAssignment.ts (2 errors) ==== - - var foo:{ ( ):void; } var bar:{ new ( ):any; } diff --git a/tests/baselines/reference/callConstructAssignment.js b/tests/baselines/reference/callConstructAssignment.js index 9f011c8ec02..3266df5314b 100644 --- a/tests/baselines/reference/callConstructAssignment.js +++ b/tests/baselines/reference/callConstructAssignment.js @@ -1,6 +1,4 @@ //// [callConstructAssignment.ts] - - var foo:{ ( ):void; } var bar:{ new ( ):any; } diff --git a/tests/baselines/reference/callOverloads2.errors.txt b/tests/baselines/reference/callOverloads2.errors.txt index 6291fa8f3de..d49dc144157 100644 --- a/tests/baselines/reference/callOverloads2.errors.txt +++ b/tests/baselines/reference/callOverloads2.errors.txt @@ -1,15 +1,13 @@ -tests/cases/compiler/callOverloads2.ts(3,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads2.ts(11,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads2.ts(13,10): error TS2389: Function implementation name must be 'Foo'. -tests/cases/compiler/callOverloads2.ts(13,10): error TS2393: Duplicate function implementation. -tests/cases/compiler/callOverloads2.ts(14,10): error TS2393: Duplicate function implementation. -tests/cases/compiler/callOverloads2.ts(16,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/callOverloads2.ts(24,1): error TS2348: Value of type 'typeof Foo' is not callable. Did you mean to include 'new'? +tests/cases/compiler/callOverloads2.ts(1,7): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads2.ts(9,10): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads2.ts(11,10): error TS2389: Function implementation name must be 'Foo'. +tests/cases/compiler/callOverloads2.ts(11,10): error TS2393: Duplicate function implementation. +tests/cases/compiler/callOverloads2.ts(12,10): error TS2393: Duplicate function implementation. +tests/cases/compiler/callOverloads2.ts(14,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/callOverloads2.ts(22,1): error TS2348: Value of type 'typeof Foo' is not callable. Did you mean to include 'new'? ==== tests/cases/compiler/callOverloads2.ts (7 errors) ==== - - class Foo { // error ~~~ !!! error TS2300: Duplicate identifier 'Foo'. diff --git a/tests/baselines/reference/callOverloads2.js b/tests/baselines/reference/callOverloads2.js index b890ee8bde9..9762a6e925f 100644 --- a/tests/baselines/reference/callOverloads2.js +++ b/tests/baselines/reference/callOverloads2.js @@ -1,6 +1,4 @@ //// [callOverloads2.ts] - - class Foo { // error bar1() { /*WScript.Echo("bar1");*/ } diff --git a/tests/baselines/reference/callOverloads3.errors.txt b/tests/baselines/reference/callOverloads3.errors.txt index ecb889bc1ab..9b14a6791a3 100644 --- a/tests/baselines/reference/callOverloads3.errors.txt +++ b/tests/baselines/reference/callOverloads3.errors.txt @@ -1,14 +1,13 @@ +tests/cases/compiler/callOverloads3.ts(1,10): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads3.ts(1,16): error TS2304: Cannot find name 'Foo'. tests/cases/compiler/callOverloads3.ts(2,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads3.ts(2,16): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads3.ts(3,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads3.ts(3,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/callOverloads3.ts(3,24): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads3.ts(4,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads3.ts(12,10): error TS2350: Only a void function can be called with the 'new' keyword. +tests/cases/compiler/callOverloads3.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/callOverloads3.ts(2,24): error TS2304: Cannot find name 'Foo'. +tests/cases/compiler/callOverloads3.ts(3,7): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads3.ts(11,10): error TS2350: Only a void function can be called with the 'new' keyword. ==== tests/cases/compiler/callOverloads3.ts (7 errors) ==== - function Foo():Foo; // error ~~~ !!! error TS2300: Duplicate identifier 'Foo'. diff --git a/tests/baselines/reference/callOverloads3.js b/tests/baselines/reference/callOverloads3.js index e5d678543c6..ecd6a39f569 100644 --- a/tests/baselines/reference/callOverloads3.js +++ b/tests/baselines/reference/callOverloads3.js @@ -1,5 +1,4 @@ //// [callOverloads3.ts] - function Foo():Foo; // error function Foo(s:string):Foo; // error class Foo { // error diff --git a/tests/baselines/reference/callOverloads4.errors.txt b/tests/baselines/reference/callOverloads4.errors.txt index 3010d7c15d8..04ac340c990 100644 --- a/tests/baselines/reference/callOverloads4.errors.txt +++ b/tests/baselines/reference/callOverloads4.errors.txt @@ -1,14 +1,13 @@ +tests/cases/compiler/callOverloads4.ts(1,10): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads4.ts(1,16): error TS2304: Cannot find name 'Foo'. tests/cases/compiler/callOverloads4.ts(2,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads4.ts(2,16): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads4.ts(3,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads4.ts(3,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/callOverloads4.ts(3,24): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads4.ts(4,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads4.ts(12,10): error TS2350: Only a void function can be called with the 'new' keyword. +tests/cases/compiler/callOverloads4.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/callOverloads4.ts(2,24): error TS2304: Cannot find name 'Foo'. +tests/cases/compiler/callOverloads4.ts(3,7): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads4.ts(11,10): error TS2350: Only a void function can be called with the 'new' keyword. ==== tests/cases/compiler/callOverloads4.ts (7 errors) ==== - function Foo():Foo; // error ~~~ !!! error TS2300: Duplicate identifier 'Foo'. diff --git a/tests/baselines/reference/callOverloads4.js b/tests/baselines/reference/callOverloads4.js index dfb274dfb6e..ea2bd8572eb 100644 --- a/tests/baselines/reference/callOverloads4.js +++ b/tests/baselines/reference/callOverloads4.js @@ -1,5 +1,4 @@ //// [callOverloads4.ts] - function Foo():Foo; // error function Foo(s:string):Foo; // error class Foo { // error diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js index caba9d7ef6e..99fb3a17a6f 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js @@ -1,5 +1,4 @@ //// [callSignatureWithoutReturnTypeAnnotationInference.ts] - // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols index dd302da3671..cf2aef2b702 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols @@ -1,56 +1,55 @@ === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts === - // Call signatures without a return type should infer one from the function body (if present) // Simple types function foo(x) { >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 4, 13)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 3, 13)) return 1; } var r = foo(1); ->r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 3)) +>r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 3)) >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) function foo2(x) { ->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14)) +>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14)) return foo(x); >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14)) } var r2 = foo2(1); ->r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 3)) ->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15)) +>r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 3)) +>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15)) function foo3() { ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) return foo3(); ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) } var r3 = foo3(); ->r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 3)) ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) +>r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 3)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) function foo4(x: T) { ->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16)) ->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17)) ->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14)) +>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16)) +>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17)) +>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14)) return x; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17)) } var r4 = foo4(1); ->r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 3)) ->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16)) +>r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 3)) +>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16)) function foo5(x) { ->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 24, 14)) +>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 23, 14)) if (true) { return 1; @@ -59,17 +58,17 @@ function foo5(x) { } } var r5 = foo5(1); ->r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 3)) ->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17)) +>r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 3)) +>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17)) function foo6(x) { ->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 33, 14)) +>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 32, 14)) try { } catch (e) { ->e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 36, 11)) +>e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 35, 11)) return []; } @@ -78,179 +77,179 @@ function foo6(x) { } } var r6 = foo6(1); ->r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 3)) ->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17)) +>r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 3)) +>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17)) function foo7(x) { ->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14)) +>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14)) return typeof x; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14)) } var r7 = foo7(1); ->r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 3)) ->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17)) +>r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 3)) +>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17)) // object types function foo8(x: number) { ->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14)) +>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14)) return { x: x }; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 52, 12)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 12)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14)) } var r8 = foo8(1); ->r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 3)) ->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17)) +>r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 3)) +>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17)) interface I { ->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17)) +>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17)) foo: string; ->foo : Symbol(I.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 56, 13)) +>foo : Symbol(I.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 55, 13)) } function foo9(x: number) { ->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 14)) +>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 14)) var i: I; ->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7)) ->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17)) +>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7)) +>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17)) return i; ->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7)) +>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7)) } var r9 = foo9(1); ->r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 3)) ->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1)) +>r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 3)) +>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1)) class C { ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17)) foo: string; ->foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 65, 9)) +>foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 64, 9)) } function foo10(x: number) { ->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 15)) +>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 15)) var c: C; ->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7)) ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17)) +>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17)) return c; ->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7)) +>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7)) } var r10 = foo10(1); ->r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 3)) ->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1)) +>r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 3)) +>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1)) module M { ->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19)) +>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19)) export var x = 1; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 14)) export class C { foo: string } ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 21)) ->foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 20)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 21)) +>foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 20)) } function foo11() { ->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1)) +>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1)) return M; ->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19)) +>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19)) } var r11 = foo11(); ->r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 3)) ->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1)) +>r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 3)) +>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1)) // merged declarations interface I2 { ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) x: number; ->x : Symbol(I2.x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 84, 14)) +>x : Symbol(I2.x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 83, 14)) } interface I2 { ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) y: number; ->y : Symbol(I2.y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 87, 14)) +>y : Symbol(I2.y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 14)) } function foo12() { ->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1)) +>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1)) var i2: I2; ->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7)) ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) +>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) return i2; ->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7)) +>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7)) } var r12 = foo12(); ->r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 3)) ->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1)) +>r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 3)) +>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1)) function m1() { return 1; } ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) module m1 { export var y = 2; } ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 22)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 22)) function foo13() { ->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31)) +>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31)) return m1; ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) } var r13 = foo13(); ->r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 3)) ->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31)) +>r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 3)) +>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31)) class c1 { ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) foo: string; ->foo : Symbol(c1.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 103, 10)) +>foo : Symbol(c1.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 102, 10)) constructor(x) { } ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 16)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 104, 16)) } module c1 { ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) export var x = 1; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 107, 14)) } function foo14() { ->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1)) +>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1)) return c1; ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) } var r14 = foo14(); ->r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 3)) ->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1)) +>r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 3)) +>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1)) enum e1 { A } ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) ->A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 9)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) +>A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 9)) module e1 { export var y = 1; } ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 22)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 22)) function foo15() { ->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31)) +>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31)) return e1; ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) } var r15 = foo15(); ->r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 120, 3)) ->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31)) +>r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 119, 3)) +>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31)) diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types index 658eff38bbb..3b2d8f25d38 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts === - // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/baselines/reference/callWithSpreadES6.js b/tests/baselines/reference/callWithSpreadES6.js index 11fa8d6edcd..9e7f244d41a 100644 --- a/tests/baselines/reference/callWithSpreadES6.js +++ b/tests/baselines/reference/callWithSpreadES6.js @@ -1,5 +1,4 @@ //// [callWithSpreadES6.ts] - interface X { foo(x: number, y: number, ...z: string[]); } diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols index 518b04162b2..dd12cd81806 100644 --- a/tests/baselines/reference/callWithSpreadES6.symbols +++ b/tests/baselines/reference/callWithSpreadES6.symbols @@ -1,160 +1,159 @@ === tests/cases/conformance/expressions/functionCalls/callWithSpreadES6.ts === - interface X { >X : Symbol(X, Decl(callWithSpreadES6.ts, 0, 0)) foo(x: number, y: number, ...z: string[]); ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 2, 8)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 2, 18)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 2, 29)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 1, 8)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 1, 18)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 1, 29)) } function foo(x: number, y: number, ...z: string[]) { ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 5, 13)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 5, 23)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 5, 34)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 4, 13)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 4, 23)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 4, 34)) } var a: string[]; ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) var z: number[]; ->z : Symbol(z, Decl(callWithSpreadES6.ts, 9, 3)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 8, 3)) var obj: X; ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) >X : Symbol(X, Decl(callWithSpreadES6.ts, 0, 0)) var xa: X[]; ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) >X : Symbol(X, Decl(callWithSpreadES6.ts, 0, 0)) foo(1, 2, "abc"); ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) foo(1, 2, ...a); ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) foo(1, 2, ...a, "abc"); ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) obj.foo(1, 2, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) obj.foo(1, 2, ...a); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) obj.foo(1, 2, ...a, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) (obj.foo)(1, 2, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) (obj.foo)(1, 2, ...a); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) (obj.foo)(1, 2, ...a, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) xa[1].foo(1, 2, "abc"); ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) xa[1].foo(1, 2, ...a); ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) xa[1].foo(1, 2, ...a, "abc"); ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) (xa[1].foo)(...[1, 2, "abc"]); >Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) class C { ->C : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) +>C : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) constructor(x: number, y: number, ...z: string[]) { ->x : Symbol(x, Decl(callWithSpreadES6.ts, 32, 16)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 32, 26)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 32, 37)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 31, 16)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 31, 26)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 31, 37)) this.foo(x, y); ->this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->this : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 32, 16)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 32, 26)) +>this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>this : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 31, 16)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 31, 26)) this.foo(x, y, ...z); ->this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->this : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 32, 16)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 32, 26)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 32, 37)) +>this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>this : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 31, 16)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 31, 26)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 31, 37)) } foo(x: number, y: number, ...z: string[]) { ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 36, 8)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 36, 18)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 36, 29)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 35, 8)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 35, 18)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 35, 29)) } } class D extends C { ->D : Symbol(D, Decl(callWithSpreadES6.ts, 38, 1)) ->C : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) +>D : Symbol(D, Decl(callWithSpreadES6.ts, 37, 1)) +>C : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) constructor() { super(1, 2); ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) super(1, 2, ...a); ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) } foo() { ->foo : Symbol(D.foo, Decl(callWithSpreadES6.ts, 44, 5)) +>foo : Symbol(D.foo, Decl(callWithSpreadES6.ts, 43, 5)) super.foo(1, 2); ->super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) +>super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) super.foo(1, 2, ...a); ->super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) } } diff --git a/tests/baselines/reference/callWithSpreadES6.types b/tests/baselines/reference/callWithSpreadES6.types index b25b8dc02b5..4ce4bb2a75c 100644 --- a/tests/baselines/reference/callWithSpreadES6.types +++ b/tests/baselines/reference/callWithSpreadES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/functionCalls/callWithSpreadES6.ts === - interface X { >X : X diff --git a/tests/baselines/reference/capturedLetConstInLoop2.js b/tests/baselines/reference/capturedLetConstInLoop2.js index e4461760af3..94bc8669cf5 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2.js +++ b/tests/baselines/reference/capturedLetConstInLoop2.js @@ -1,6 +1,4 @@ //// [capturedLetConstInLoop2.ts] - - // ========let function foo0(x) { for (let x of []) { diff --git a/tests/baselines/reference/capturedLetConstInLoop2.symbols b/tests/baselines/reference/capturedLetConstInLoop2.symbols index 8fb2de72999..d0a174e7782 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop2.symbols @@ -1,519 +1,517 @@ === tests/cases/compiler/capturedLetConstInLoop2.ts === - - // ========let function foo0(x) { >foo0 : Symbol(foo0, Decl(capturedLetConstInLoop2.ts, 0, 0)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 3, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 1, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 2, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 3, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 3, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 3, 11)) } } function foo0_1(x) { ->foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2.ts, 9, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 11, 16)) +>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2.ts, 7, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 9, 16)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 10, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 11, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 11, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 11, 11)) } } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2.ts, 17, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 19, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2.ts, 15, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 17, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 19, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 19, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 19, 11)) } } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2.ts, 25, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2.ts, 23, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 25, 14)) while (1 === 1) { let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 27, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 27, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 27, 11)) } } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2.ts, 33, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2.ts, 31, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 33, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 36, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 36, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 36, 11)) } while (1 === 1) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2.ts, 42, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 44, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2.ts, 40, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 42, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 43, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 44, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 45, 11)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 44, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 44, 11)) } } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2.ts, 51, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 53, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2.ts, 49, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 51, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 52, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 53, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 53, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 53, 11)) } } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2.ts, 59, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2.ts, 57, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 60, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 62, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 63, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 63, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 63, 11)) } } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2.ts, 69, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2.ts, 67, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 69, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 71, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 72, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 72, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 72, 11)) } while (1 === 1) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2.ts, 78, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2.ts, 76, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 79, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 82, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 82, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 82, 11)) } } ///=======const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2.ts, 88, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 90, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2.ts, 86, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 88, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 89, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 90, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 90, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 90, 13)) } } function foo0_1_c(x) { ->foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2.ts, 96, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 98, 18)) +>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2.ts, 94, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 96, 18)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 97, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 98, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 98, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 98, 13)) } } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2.ts, 104, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 106, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2.ts, 102, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 104, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 106, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 106, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 106, 13)) } } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2.ts, 112, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2.ts, 110, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 112, 16)) while (1 === 1) { const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 114, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 114, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 114, 13)) } } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2.ts, 120, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2.ts, 118, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 120, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 123, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 123, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 123, 13)) } while (1 === 1) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2.ts, 129, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 131, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2.ts, 127, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 129, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 132, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 132, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 130, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 130, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 131, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 132, 13)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 131, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 131, 13)) } } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2.ts, 138, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 140, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2.ts, 136, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 138, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 139, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 140, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 140, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 140, 13)) } } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2.ts, 146, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2.ts, 144, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 147, 16)) while (1 === 1) { const x = 1, y =1 ; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 149, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 150, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 150, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 150, 13)) } } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2.ts, 156, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2.ts, 154, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 156, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 158, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 159, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 159, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 159, 13)) } while (1 === 1) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2.ts, 165, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2.ts, 163, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 166, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 169, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 169, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 169, 13)) } } diff --git a/tests/baselines/reference/capturedLetConstInLoop2.types b/tests/baselines/reference/capturedLetConstInLoop2.types index 4f819d3c3f9..be90b52b334 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2.types +++ b/tests/baselines/reference/capturedLetConstInLoop2.types @@ -1,6 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop2.ts === - - // ========let function foo0(x) { >foo0 : (x: any) => void diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.js b/tests/baselines/reference/capturedLetConstInLoop2_ES6.js index aac040d4d29..59bd81b5a4d 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop2_ES6.ts] - // ========let function foo0(x) { for (let x of []) { diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols index 0dd74bc4b25..ff1054c2b21 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols @@ -1,518 +1,517 @@ === tests/cases/compiler/capturedLetConstInLoop2_ES6.ts === - // ========let function foo0(x) { >foo0 : Symbol(foo0, Decl(capturedLetConstInLoop2_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 1, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11)) } } function foo0_1(x) { ->foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2_ES6.ts, 8, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 16)) +>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2_ES6.ts, 7, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 9, 16)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11)) } } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2_ES6.ts, 16, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2_ES6.ts, 15, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 17, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11)) } } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2_ES6.ts, 24, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2_ES6.ts, 23, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14)) while (1 === 1) { let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11)) } } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2_ES6.ts, 32, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 34, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2_ES6.ts, 31, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 33, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) } while (1 === 1) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2_ES6.ts, 41, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 43, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2_ES6.ts, 40, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 42, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 43, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11)) } } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2_ES6.ts, 50, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2_ES6.ts, 49, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 51, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 52, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11)) } } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2_ES6.ts, 58, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 61, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2_ES6.ts, 57, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 60, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 62, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) } } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2_ES6.ts, 68, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 70, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2_ES6.ts, 67, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 69, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 71, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) } while (1 === 1) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2_ES6.ts, 77, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 80, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2_ES6.ts, 76, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 79, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) } } ///=======const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2_ES6.ts, 87, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2_ES6.ts, 86, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 88, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13)) } } function foo0_1_c(x) { ->foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2_ES6.ts, 95, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 18)) +>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2_ES6.ts, 94, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 96, 18)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13)) } } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2_ES6.ts, 103, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2_ES6.ts, 102, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 104, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13)) } } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2_ES6.ts, 111, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2_ES6.ts, 110, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16)) while (1 === 1) { const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13)) } } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2_ES6.ts, 119, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 121, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2_ES6.ts, 118, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 120, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) } while (1 === 1) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2_ES6.ts, 128, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 130, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2_ES6.ts, 127, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 129, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 131, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 131, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 130, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 130, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13)) } } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2_ES6.ts, 137, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2_ES6.ts, 136, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 138, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 139, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13)) } } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2_ES6.ts, 145, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 148, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2_ES6.ts, 144, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 147, 16)) while (1 === 1) { const x = 1, y =1 ; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 149, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) } } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2_ES6.ts, 155, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 157, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2_ES6.ts, 154, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 156, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 158, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) } while (1 === 1) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2_ES6.ts, 164, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 167, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2_ES6.ts, 163, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 166, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) } } diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.types b/tests/baselines/reference/capturedLetConstInLoop2_ES6.types index e72221d85cd..fb1779237ef 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop2_ES6.ts === - // ========let function foo0(x) { >foo0 : (x: any) => void diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.js b/tests/baselines/reference/capturedLetConstInLoop3_ES6.js index f27713a52a8..367db066edd 100644 --- a/tests/baselines/reference/capturedLetConstInLoop3_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop3_ES6.ts] - ///=========let declare function use(a: any); function foo0(x) { diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols index b07a724cbbe..7ec20d74e6d 100644 --- a/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols @@ -1,566 +1,565 @@ === tests/cases/compiler/capturedLetConstInLoop3_ES6.ts === - ///=========let declare function use(a: any); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(capturedLetConstInLoop3_ES6.ts, 2, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop3_ES6.ts, 1, 21)) function foo0(x) { ->foo0 : Symbol(foo0, Decl(capturedLetConstInLoop3_ES6.ts, 2, 29)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 14)) +>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop3_ES6.ts, 1, 29)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 2, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) } function foo0_1(x) { ->foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop3_ES6.ts, 11, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 16)) +>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop3_ES6.ts, 10, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 12, 16)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop3_ES6.ts, 21, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop3_ES6.ts, 20, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 22, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop3_ES6.ts, 31, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 33, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop3_ES6.ts, 30, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 32, 14)) while (1 === 1) { let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop3_ES6.ts, 42, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 44, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop3_ES6.ts, 41, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 43, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 45, 11)) var v; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 45, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 45, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop3_ES6.ts, 53, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 55, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop3_ES6.ts, 52, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 54, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) var v = y; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop3_ES6.ts, 64, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop3_ES6.ts, 63, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 65, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 66, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 66, 19)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 66, 19)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop3_ES6.ts, 74, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 77, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop3_ES6.ts, 73, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 76, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 78, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 78, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 78, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) } use(v) >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop3_ES6.ts, 86, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 88, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop3_ES6.ts, 85, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 87, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 89, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 89, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 89, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop3_ES6.ts, 97, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 100, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop3_ES6.ts, 96, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 99, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) } //===const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop3_ES6.ts, 109, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop3_ES6.ts, 108, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 110, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) } function foo0_1_c(x) { ->foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop3_ES6.ts, 119, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 18)) +>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop3_ES6.ts, 118, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 120, 18)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop3_ES6.ts, 129, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop3_ES6.ts, 128, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 130, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop3_ES6.ts, 139, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 141, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop3_ES6.ts, 138, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 140, 16)) while (1 === 1) { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop3_ES6.ts, 150, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 152, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop3_ES6.ts, 149, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 151, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 153, 13)) var v; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 153, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 153, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop3_ES6.ts, 161, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 163, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop3_ES6.ts, 160, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 162, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 163, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 163, 14)) var v = y; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 163, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 165, 13)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 165, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 165, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop3_ES6.ts, 172, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop3_ES6.ts, 171, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 173, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 174, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 174, 21)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 174, 21)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop3_ES6.ts, 182, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 185, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop3_ES6.ts, 181, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 184, 16)) while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 186, 20)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 186, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 186, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) } use(v) >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop3_ES6.ts, 194, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 196, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop3_ES6.ts, 193, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 195, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 197, 20)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 197, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 197, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop3_ES6.ts, 205, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 208, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop3_ES6.ts, 204, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 207, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.types b/tests/baselines/reference/capturedLetConstInLoop3_ES6.types index 9c11ae62574..5a8d77c252c 100644 --- a/tests/baselines/reference/capturedLetConstInLoop3_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop3_ES6.ts === - ///=========let declare function use(a: any); >use : (a: any) => any diff --git a/tests/baselines/reference/capturedLetConstInLoop4.js b/tests/baselines/reference/capturedLetConstInLoop4.js index 2cade08f0a6..bc259a73a88 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4.js +++ b/tests/baselines/reference/capturedLetConstInLoop4.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop4.ts] - //======let export function exportedFoo() { return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; diff --git a/tests/baselines/reference/capturedLetConstInLoop4.symbols b/tests/baselines/reference/capturedLetConstInLoop4.symbols index 19e78bbf2b4..6554a5a9686 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop4.symbols @@ -1,394 +1,393 @@ === tests/cases/compiler/capturedLetConstInLoop4.ts === - //======let export function exportedFoo() { >exportedFoo : Symbol(exportedFoo, Decl(capturedLetConstInLoop4.ts, 0, 0)) return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 6, 7)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 18, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 45, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 52, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 59, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 66, 7)) } for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) var v0 = x; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 6, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) (function() { return x + v0}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 6, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) } for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) var v00 = x; ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) } for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) var v1 = x; ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 18, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) (function() { return x + v1}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 18, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) } while (1 === 1) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) var v2 = x; ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) (function() { return x + v2}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 25, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) } do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) var v3 = x; ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) (function() { return x + v3}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 32, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 37, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) var v4 = x; ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) (function() { return x + v4}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 39, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) } for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 44, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) var v5 = x; ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 45, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) (function() { return x + y + v5}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 44, 15)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 45, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 44, 15)) } while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 51, 10)) var v6 = x; ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 52, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) (function() { return x + y + v6}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 51, 10)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 52, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 51, 10)) } do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 58, 10)) var v7 = x; ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 59, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) (function() { return x + y + v7}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 58, 10)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 59, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 58, 10)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) var v8 = x; ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) (function() { return x + y + v8}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 66, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) } //======const export function exportedFoo2() { ->exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4.ts, 70, 1)) +>exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4.ts, 69, 1)) return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7)) ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 84, 7)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 77, 7)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 83, 7)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 89, 7)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 96, 7)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 103, 7)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 110, 7)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 116, 7)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 123, 7)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 130, 7)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 137, 7)) } for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) var v0_c = x; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 77, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) (function() { return x + v0_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 77, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) } for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) var v00_c = x; ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 84, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 83, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) } for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) var v1_c = x; ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 89, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) (function() { return x + v1_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 89, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) } while (1 === 1) { const x =1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) var v2_c = x; ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 96, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) (function() { return x + v2_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 96, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) } do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) var v3_c = x; ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 103, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) (function() { return x + v3_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 103, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 109, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 109, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 108, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 108, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) var v4_c = x; ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 110, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) (function() { return x + v4_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 110, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) } for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 115, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) var v5_c = x; ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 116, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) (function() { return x + y + v5_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 115, 17)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 116, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 115, 17)) } while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 122, 16)) var v6_c = x; ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 123, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) (function() { return x + y + v6_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 122, 16)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 123, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 122, 16)) } do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 129, 16)) var v7_c = x; ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 130, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) (function() { return x + y + v7_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 129, 16)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 130, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 129, 16)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) var v8_c = x; ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 137, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) (function() { return x + y + v8_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 137, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop4.types b/tests/baselines/reference/capturedLetConstInLoop4.types index 2c48463adec..2fcff7625a1 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4.types +++ b/tests/baselines/reference/capturedLetConstInLoop4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop4.ts === - //======let export function exportedFoo() { >exportedFoo : () => string diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.js b/tests/baselines/reference/capturedLetConstInLoop4_ES6.js index 83b0af1f23c..b1b60535475 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop4_ES6.ts] - //======let export function exportedFoo() { return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; @@ -145,6 +144,7 @@ for (const y = 0; y < 1;) { //// [capturedLetConstInLoop4_ES6.js] //======let +//======let export function exportedFoo() { return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; } diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols index cc5a2ad54bc..df72686e7be 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols @@ -1,394 +1,393 @@ === tests/cases/compiler/capturedLetConstInLoop4_ES6.ts === - //======let export function exportedFoo() { >exportedFoo : Symbol(exportedFoo, Decl(capturedLetConstInLoop4_ES6.ts, 0, 0)) return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 6, 7)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 18, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 45, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) } for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) var v0 = x; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 6, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) (function() { return x + v0}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 6, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) } for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) var v00 = x; ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) } for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) var v1 = x; ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 18, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) (function() { return x + v1}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 18, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) } while (1 === 1) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) var v2 = x; ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) (function() { return x + v2}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) } do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) var v3 = x; ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) (function() { return x + v3}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 37, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) var v4 = x; ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) (function() { return x + v4}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) } for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 44, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) var v5 = x; ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 45, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) (function() { return x + y + v5}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 44, 15)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 45, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 44, 15)) } while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 51, 10)) var v6 = x; ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) (function() { return x + y + v6}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 51, 10)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 51, 10)) } do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 58, 10)) var v7 = x; ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) (function() { return x + y + v7}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 58, 10)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 58, 10)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) var v8 = x; ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) (function() { return x + y + v8}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) } //======const export function exportedFoo2() { ->exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4_ES6.ts, 70, 1)) +>exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4_ES6.ts, 69, 1)) return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7)) ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 84, 7)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 77, 7)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 83, 7)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 89, 7)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 96, 7)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 103, 7)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 110, 7)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 116, 7)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 123, 7)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 130, 7)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 137, 7)) } for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) var v0_c = x; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 77, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) (function() { return x + v0_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 77, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) } for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) var v00_c = x; ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 84, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 83, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) } for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) var v1_c = x; ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 89, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) (function() { return x + v1_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 89, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) } while (1 === 1) { const x =1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) var v2_c = x; ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 96, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) (function() { return x + v2_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 96, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) } do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) var v3_c = x; ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 103, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) (function() { return x + v3_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 103, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 109, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 109, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 108, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 108, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) var v4_c = x; ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 110, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) (function() { return x + v4_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 110, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) } for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 115, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) var v5_c = x; ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 116, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) (function() { return x + y + v5_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 115, 17)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 116, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 115, 17)) } while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 122, 16)) var v6_c = x; ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 123, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) (function() { return x + y + v6_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 122, 16)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 123, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 122, 16)) } do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 129, 16)) var v7_c = x; ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 130, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) (function() { return x + y + v7_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 129, 16)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 130, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 129, 16)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) var v8_c = x; ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 137, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) (function() { return x + y + v8_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 137, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.types b/tests/baselines/reference/capturedLetConstInLoop4_ES6.types index 32af60f24e4..546cdd93b43 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop4_ES6.ts === - //======let export function exportedFoo() { >exportedFoo : () => string diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt b/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt index a9a4742631a..1826ffa99f7 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt +++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(175,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. -tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(230,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. +tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(174,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. +tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(229,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. ==== tests/cases/compiler/capturedLetConstInLoop5_ES6.ts (2 errors) ==== - declare function use(a: any); //====let diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.js b/tests/baselines/reference/capturedLetConstInLoop5_ES6.js index 0f0624b8a8b..da48929c959 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop5_ES6.ts] - declare function use(a: any); //====let diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js index a06d9c6f747..783140426d2 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop9_ES6.ts] - for (let x = 0; x < 1; ++x) { let x; (function() { return x }); diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols index c9b8fdb392c..4d4013096fc 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols @@ -1,116 +1,115 @@ === tests/cases/compiler/capturedLetConstInLoop9_ES6.ts === - for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 0, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 0, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 0, 8)) let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 4, 11)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 4, 11)) } try { } catch (e) { ->e : Symbol(e, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11)) +>e : Symbol(e, Decl(capturedLetConstInLoop9_ES6.ts, 9, 11)) let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 11, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 11, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11)) } switch (x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) case 1: let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 17, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 16, 15)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 17, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 16, 15)) break; } while (1 == 1) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 23, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 22, 11)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 23, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 22, 11)) } class A { ->A : Symbol(A, Decl(capturedLetConstInLoop9_ES6.ts, 25, 5)) +>A : Symbol(A, Decl(capturedLetConstInLoop9_ES6.ts, 24, 5)) m() { ->m : Symbol(A.m, Decl(capturedLetConstInLoop9_ES6.ts, 27, 13)) +>m : Symbol(A.m, Decl(capturedLetConstInLoop9_ES6.ts, 26, 13)) return x + 1; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) } } } declare function use(a: any); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 34, 21)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 33, 21)) function foo() { ->foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 34, 29)) +>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 33, 29)) l0: for (let a of []) { ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) if (a === 1) { ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) break; } if (a === 2) { ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) break l0; } for (let b of []) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) var [{x, y:z}] = [{x:1, y:2}]; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 18)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 49, 35)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 49, 20)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 31)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 49, 35)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 48, 18)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 48, 35)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 48, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 48, 31)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 48, 35)) if (b === 1) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) break; } if (b === 2) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) break l0; } l1: if (b === 3) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) break l1; } @@ -119,77 +118,77 @@ function foo() { } for (let b of []) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) var [{x1, y:z1}] = [{x1:1, y:arguments.length}]; ->x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 18)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 68, 38)) ->z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 21)) ->x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 33)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 68, 38)) +>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 18)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 67, 38)) +>z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 21)) +>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 33)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 67, 38)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) if (b === 1) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) break; } if (b === 2) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) break l0; } () => b ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) return 100; } () => a; ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) } use(x); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 18)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 48, 18)) use(z); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 49, 20)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 48, 20)) use(x1); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 18)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 18)) use(z1); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 21)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 21)) } function foo2() { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 88, 1)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 87, 1)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) if (x === 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) break; } else if (x === 2) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) continue; } while (1 === 1) { if (x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) break; } @@ -199,17 +198,17 @@ function foo2() { } switch(x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) case 1: break; case 2: continue; } for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 112, 16)) switch(y) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 112, 16)) case 1: break; case 2: continue; @@ -219,50 +218,50 @@ function foo2() { } class C { ->C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1)) +>C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 119, 1)) constructor(private N: number) { } ->N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) +>N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 122, 16)) foo() { ->foo : Symbol(C.foo, Decl(capturedLetConstInLoop9_ES6.ts, 123, 38)) +>foo : Symbol(C.foo, Decl(capturedLetConstInLoop9_ES6.ts, 122, 38)) for (let i = 0; i < 100; i++) { ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) let f = () => this.N * i; ->f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 126, 15)) ->this.N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) ->this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1)) ->N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 125, 15)) +>this.N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 122, 16)) +>this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 119, 1)) +>N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 122, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) } } } function foo3 () { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 129, 1)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 128, 1)) let x = arguments.length; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 132, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 131, 7)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 132, 12)) let z = arguments.length; ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 133, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return y + z + arguments.length; }); ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 132, 12)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 133, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types index be4457315ee..26d2b770a31 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop9_ES6.ts === - for (let x = 0; x < 1; ++x) { >x : number >0 : 0 diff --git a/tests/baselines/reference/castTest.js b/tests/baselines/reference/castTest.js index ef9ef084d98..930086bdd94 100644 --- a/tests/baselines/reference/castTest.js +++ b/tests/baselines/reference/castTest.js @@ -1,5 +1,4 @@ //// [castTest.ts] - var x : any = 0; var z = x; var y = x + z; diff --git a/tests/baselines/reference/castTest.symbols b/tests/baselines/reference/castTest.symbols index 944cc8238e6..9d03cb008ba 100644 --- a/tests/baselines/reference/castTest.symbols +++ b/tests/baselines/reference/castTest.symbols @@ -1,84 +1,83 @@ === tests/cases/compiler/castTest.ts === - var x : any = 0; ->x : Symbol(x, Decl(castTest.ts, 1, 3)) +>x : Symbol(x, Decl(castTest.ts, 0, 3)) var z = x; ->z : Symbol(z, Decl(castTest.ts, 2, 3)) ->x : Symbol(x, Decl(castTest.ts, 1, 3)) +>z : Symbol(z, Decl(castTest.ts, 1, 3)) +>x : Symbol(x, Decl(castTest.ts, 0, 3)) var y = x + z; ->y : Symbol(y, Decl(castTest.ts, 3, 3)) ->x : Symbol(x, Decl(castTest.ts, 1, 3)) ->z : Symbol(z, Decl(castTest.ts, 2, 3)) +>y : Symbol(y, Decl(castTest.ts, 2, 3)) +>x : Symbol(x, Decl(castTest.ts, 0, 3)) +>z : Symbol(z, Decl(castTest.ts, 1, 3)) var a = 0; ->a : Symbol(a, Decl(castTest.ts, 5, 3)) +>a : Symbol(a, Decl(castTest.ts, 4, 3)) var b = true; ->b : Symbol(b, Decl(castTest.ts, 6, 3)) +>b : Symbol(b, Decl(castTest.ts, 5, 3)) var s = ""; ->s : Symbol(s, Decl(castTest.ts, 7, 3)) +>s : Symbol(s, Decl(castTest.ts, 6, 3)) var ar = null; ->ar : Symbol(ar, Decl(castTest.ts, 9, 3)) +>ar : Symbol(ar, Decl(castTest.ts, 8, 3)) var f = <(res : number) => void>null; ->f : Symbol(f, Decl(castTest.ts, 11, 3)) ->res : Symbol(res, Decl(castTest.ts, 11, 10)) +>f : Symbol(f, Decl(castTest.ts, 10, 3)) +>res : Symbol(res, Decl(castTest.ts, 10, 10)) declare class Point ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) { x: number; ->x : Symbol(Point.x, Decl(castTest.ts, 14, 1)) +>x : Symbol(Point.x, Decl(castTest.ts, 13, 1)) y: number; ->y : Symbol(Point.y, Decl(castTest.ts, 15, 14)) +>y : Symbol(Point.y, Decl(castTest.ts, 14, 14)) add(dx: number, dy: number): Point; ->add : Symbol(Point.add, Decl(castTest.ts, 16, 14)) ->dx : Symbol(dx, Decl(castTest.ts, 17, 8)) ->dy : Symbol(dy, Decl(castTest.ts, 17, 19)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>add : Symbol(Point.add, Decl(castTest.ts, 15, 14)) +>dx : Symbol(dx, Decl(castTest.ts, 16, 8)) +>dy : Symbol(dy, Decl(castTest.ts, 16, 19)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) mult(p: Point): Point; ->mult : Symbol(Point.mult, Decl(castTest.ts, 17, 39)) ->p : Symbol(p, Decl(castTest.ts, 18, 9)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>mult : Symbol(Point.mult, Decl(castTest.ts, 16, 39)) +>p : Symbol(p, Decl(castTest.ts, 17, 9)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) constructor(x: number, y: number); ->x : Symbol(x, Decl(castTest.ts, 19, 16)) ->y : Symbol(y, Decl(castTest.ts, 19, 26)) +>x : Symbol(x, Decl(castTest.ts, 18, 16)) +>y : Symbol(y, Decl(castTest.ts, 18, 26)) } var p_cast = ({ ->p_cast : Symbol(p_cast, Decl(castTest.ts, 22, 3)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>p_cast : Symbol(p_cast, Decl(castTest.ts, 21, 3)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) x: 0, ->x : Symbol(x, Decl(castTest.ts, 22, 23)) +>x : Symbol(x, Decl(castTest.ts, 21, 23)) y: 0, ->y : Symbol(y, Decl(castTest.ts, 23, 9)) +>y : Symbol(y, Decl(castTest.ts, 22, 9)) add: function(dx, dy) { ->add : Symbol(add, Decl(castTest.ts, 24, 9)) ->dx : Symbol(dx, Decl(castTest.ts, 25, 18)) ->dy : Symbol(dy, Decl(castTest.ts, 25, 21)) +>add : Symbol(add, Decl(castTest.ts, 23, 9)) +>dx : Symbol(dx, Decl(castTest.ts, 24, 18)) +>dy : Symbol(dy, Decl(castTest.ts, 24, 21)) return new Point(this.x + dx, this.y + dy); ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) ->dx : Symbol(dx, Decl(castTest.ts, 25, 18)) ->dy : Symbol(dy, Decl(castTest.ts, 25, 21)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) +>dx : Symbol(dx, Decl(castTest.ts, 24, 18)) +>dy : Symbol(dy, Decl(castTest.ts, 24, 21)) }, mult: function(p) { return p; } ->mult : Symbol(mult, Decl(castTest.ts, 27, 6)) ->p : Symbol(p, Decl(castTest.ts, 28, 19)) ->p : Symbol(p, Decl(castTest.ts, 28, 19)) +>mult : Symbol(mult, Decl(castTest.ts, 26, 6)) +>p : Symbol(p, Decl(castTest.ts, 27, 19)) +>p : Symbol(p, Decl(castTest.ts, 27, 19)) }) diff --git a/tests/baselines/reference/castTest.types b/tests/baselines/reference/castTest.types index 666b2ccf78e..4032aa8ac24 100644 --- a/tests/baselines/reference/castTest.types +++ b/tests/baselines/reference/castTest.types @@ -1,5 +1,4 @@ === tests/cases/compiler/castTest.ts === - var x : any = 0; >x : any >0 : 0 diff --git a/tests/baselines/reference/circularIndexedAccessErrors.errors.txt b/tests/baselines/reference/circularIndexedAccessErrors.errors.txt index f76cfca073e..d2e9171065b 100644 --- a/tests/baselines/reference/circularIndexedAccessErrors.errors.txt +++ b/tests/baselines/reference/circularIndexedAccessErrors.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(3,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(7,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(19,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(23,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(38,24): error TS2313: Type parameter 'T' has a circular constraint. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(38,30): error TS2536: Type '"hello"' cannot be used to index type 'T'. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(2,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(6,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(18,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(22,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(37,24): error TS2313: Type parameter 'T' has a circular constraint. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(37,30): error TS2536: Type '"hello"' cannot be used to index type 'T'. ==== tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts (6 errors) ==== - type T1 = { x: T1["x"]; // Error ~~~~~~~~~~~ diff --git a/tests/baselines/reference/circularIndexedAccessErrors.js b/tests/baselines/reference/circularIndexedAccessErrors.js index 97d059bce19..eee09e853a2 100644 --- a/tests/baselines/reference/circularIndexedAccessErrors.js +++ b/tests/baselines/reference/circularIndexedAccessErrors.js @@ -1,5 +1,4 @@ //// [circularIndexedAccessErrors.ts] - type T1 = { x: T1["x"]; // Error }; diff --git a/tests/baselines/reference/circularObjectLiteralAccessors.js b/tests/baselines/reference/circularObjectLiteralAccessors.js index 6d99a8f25fc..34d114268ca 100644 --- a/tests/baselines/reference/circularObjectLiteralAccessors.js +++ b/tests/baselines/reference/circularObjectLiteralAccessors.js @@ -1,5 +1,4 @@ //// [circularObjectLiteralAccessors.ts] - // Repro from #6000 const a = { diff --git a/tests/baselines/reference/circularObjectLiteralAccessors.symbols b/tests/baselines/reference/circularObjectLiteralAccessors.symbols index 21e613c97fe..ef2b6606d00 100644 --- a/tests/baselines/reference/circularObjectLiteralAccessors.symbols +++ b/tests/baselines/reference/circularObjectLiteralAccessors.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/circularObjectLiteralAccessors.ts === - // Repro from #6000 const a = { ->a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 3, 5)) +>a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 2, 5)) b: { ->b : Symbol(b, Decl(circularObjectLiteralAccessors.ts, 3, 11)) +>b : Symbol(b, Decl(circularObjectLiteralAccessors.ts, 2, 11)) get foo(): string { ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 4, 8), Decl(circularObjectLiteralAccessors.ts, 7, 10)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 3, 8), Decl(circularObjectLiteralAccessors.ts, 6, 10)) return a.foo; ->a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) ->a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 3, 5)) ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) +>a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) +>a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 2, 5)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) }, set foo(value: string) { ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 4, 8), Decl(circularObjectLiteralAccessors.ts, 7, 10)) ->value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 8, 16)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 3, 8), Decl(circularObjectLiteralAccessors.ts, 6, 10)) +>value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 7, 16)) a.foo = value; ->a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) ->a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 3, 5)) ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) ->value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 8, 16)) +>a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) +>a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 2, 5)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) +>value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 7, 16)) } }, foo: '' ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) }; diff --git a/tests/baselines/reference/circularObjectLiteralAccessors.types b/tests/baselines/reference/circularObjectLiteralAccessors.types index e190ea5e6d3..361f063780b 100644 --- a/tests/baselines/reference/circularObjectLiteralAccessors.types +++ b/tests/baselines/reference/circularObjectLiteralAccessors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/circularObjectLiteralAccessors.ts === - // Repro from #6000 const a = { diff --git a/tests/baselines/reference/circularReferenceInImport.js b/tests/baselines/reference/circularReferenceInImport.js index 8b49f45dbd2..432a03d090c 100644 --- a/tests/baselines/reference/circularReferenceInImport.js +++ b/tests/baselines/reference/circularReferenceInImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/circularReferenceInImport.ts] //// //// [db.d.ts] - declare namespace Db { export import Types = Db; } diff --git a/tests/baselines/reference/circularReferenceInImport.symbols b/tests/baselines/reference/circularReferenceInImport.symbols index b74ac14b5ab..d5415f1fef1 100644 --- a/tests/baselines/reference/circularReferenceInImport.symbols +++ b/tests/baselines/reference/circularReferenceInImport.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/db.d.ts === - declare namespace Db { >Db : Symbol(Types, Decl(db.d.ts, 0, 0)) export import Types = Db; ->Types : Symbol(Types, Decl(db.d.ts, 1, 22)) +>Types : Symbol(Types, Decl(db.d.ts, 0, 22)) >Db : Symbol(Types, Decl(db.d.ts, 0, 0)) } diff --git a/tests/baselines/reference/circularReferenceInImport.types b/tests/baselines/reference/circularReferenceInImport.types index d8db7f56231..72e5f2e301c 100644 --- a/tests/baselines/reference/circularReferenceInImport.types +++ b/tests/baselines/reference/circularReferenceInImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/db.d.ts === - declare namespace Db { >Db : typeof Types diff --git a/tests/baselines/reference/classAbstractAccessor.errors.txt b/tests/baselines/reference/classAbstractAccessor.errors.txt index b43cfa9d7f1..9afc61fb5fb 100644 --- a/tests/baselines/reference/classAbstractAccessor.errors.txt +++ b/tests/baselines/reference/classAbstractAccessor.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(4,17): error TS1318: An abstract accessor cannot have an implementation. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(6,17): error TS1318: An abstract accessor cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(3,17): error TS1318: An abstract accessor cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(5,17): error TS1318: An abstract accessor cannot have an implementation. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts (2 errors) ==== - abstract class A { abstract get a(); abstract get aa() { return 1; } // error diff --git a/tests/baselines/reference/classAbstractAccessor.js b/tests/baselines/reference/classAbstractAccessor.js index a1edf0cb88d..d953a4ac0c2 100644 --- a/tests/baselines/reference/classAbstractAccessor.js +++ b/tests/baselines/reference/classAbstractAccessor.js @@ -1,5 +1,4 @@ //// [classAbstractAccessor.ts] - abstract class A { abstract get a(); abstract get aa() { return 1; } // error diff --git a/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt b/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt index a3e9e077914..0f834665346 100644 --- a/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt +++ b/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(8,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(7,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof A'. Cannot assign an abstract constructor type to a non-abstract constructor type. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(10,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(9,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof C'. Cannot assign an abstract constructor type to a non-abstract constructor type. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(13,1): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'B'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts (3 errors) ==== - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractConstructorAssignability.js b/tests/baselines/reference/classAbstractConstructorAssignability.js index 5df6d169e04..8376e5c1a45 100644 --- a/tests/baselines/reference/classAbstractConstructorAssignability.js +++ b/tests/baselines/reference/classAbstractConstructorAssignability.js @@ -1,5 +1,4 @@ //// [classAbstractConstructorAssignability.ts] - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractExtends.errors.txt b/tests/baselines/reference/classAbstractExtends.errors.txt index 550067cd0e1..60b0f9ae0ac 100644 --- a/tests/baselines/reference/classAbstractExtends.errors.txt +++ b/tests/baselines/reference/classAbstractExtends.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractExtends.ts(10,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractExtends.ts(9,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractExtends.ts (1 errors) ==== - class A { foo() {} } diff --git a/tests/baselines/reference/classAbstractExtends.js b/tests/baselines/reference/classAbstractExtends.js index 69c962509db..0f63a08d2e9 100644 --- a/tests/baselines/reference/classAbstractExtends.js +++ b/tests/baselines/reference/classAbstractExtends.js @@ -1,5 +1,4 @@ //// [classAbstractExtends.ts] - class A { foo() {} } diff --git a/tests/baselines/reference/classAbstractFactoryFunction.errors.txt b/tests/baselines/reference/classAbstractFactoryFunction.errors.txt index f1b43adae59..1b281f35260 100644 --- a/tests/baselines/reference/classAbstractFactoryFunction.errors.txt +++ b/tests/baselines/reference/classAbstractFactoryFunction.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(10,12): error TS2511: Cannot create an instance of the abstract class 'B'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(14,6): error TS2345: Argument of type 'typeof B' is not assignable to parameter of type 'typeof A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(9,12): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(13,6): error TS2345: Argument of type 'typeof B' is not assignable to parameter of type 'typeof A'. Cannot assign an abstract constructor type to a non-abstract constructor type. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts (2 errors) ==== - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractFactoryFunction.js b/tests/baselines/reference/classAbstractFactoryFunction.js index abc3235a3d3..903faf53a50 100644 --- a/tests/baselines/reference/classAbstractFactoryFunction.js +++ b/tests/baselines/reference/classAbstractFactoryFunction.js @@ -1,5 +1,4 @@ //// [classAbstractFactoryFunction.ts] - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractInstantiations1.errors.txt b/tests/baselines/reference/classAbstractInstantiations1.errors.txt index 24a969fc6b8..d1c159858a4 100644 --- a/tests/baselines/reference/classAbstractInstantiations1.errors.txt +++ b/tests/baselines/reference/classAbstractInstantiations1.errors.txt @@ -1,10 +1,9 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(11,1): error TS2511: Cannot create an instance of the abstract class 'A'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(13,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(15,1): error TS2511: Cannot create an instance of the abstract class 'C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(14,1): error TS2511: Cannot create an instance of the abstract class 'C'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts (3 errors) ==== - // // Calling new with (non)abstract classes. // diff --git a/tests/baselines/reference/classAbstractInstantiations1.js b/tests/baselines/reference/classAbstractInstantiations1.js index 6722665b62d..df69dbac8ee 100644 --- a/tests/baselines/reference/classAbstractInstantiations1.js +++ b/tests/baselines/reference/classAbstractInstantiations1.js @@ -1,5 +1,4 @@ //// [classAbstractInstantiations1.ts] - // // Calling new with (non)abstract classes. // diff --git a/tests/baselines/reference/classAbstractSuperCalls.errors.txt b/tests/baselines/reference/classAbstractSuperCalls.errors.txt index a9dbf0f7ba8..771d0369890 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.errors.txt +++ b/tests/baselines/reference/classAbstractSuperCalls.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,41): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(13,26): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(13,41): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts (2 errors) ==== - class A { foo() { return 1; } } diff --git a/tests/baselines/reference/classAbstractSuperCalls.js b/tests/baselines/reference/classAbstractSuperCalls.js index 125f5b3883f..9bba784ca93 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.js +++ b/tests/baselines/reference/classAbstractSuperCalls.js @@ -1,5 +1,4 @@ //// [classAbstractSuperCalls.ts] - class A { foo() { return 1; } } diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.symbols b/tests/baselines/reference/classAndInterfaceMerge.d.symbols index 84fc2b129c1..ff909ad4923 100644 --- a/tests/baselines/reference/classAndInterfaceMerge.d.symbols +++ b/tests/baselines/reference/classAndInterfaceMerge.d.symbols @@ -1,39 +1,38 @@ === tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts === - interface C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) declare class C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) interface C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) interface C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) declare module M { ->M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 7, 15), Decl(classAndInterfaceMerge.d.ts, 20, 1)) +>M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 6, 15), Decl(classAndInterfaceMerge.d.ts, 19, 1)) interface C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) class C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) interface C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) interface C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) export class C2 { } ->C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 17, 20), Decl(classAndInterfaceMerge.d.ts, 22, 18)) +>C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 16, 20), Decl(classAndInterfaceMerge.d.ts, 21, 18)) } declare module M { ->M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 7, 15), Decl(classAndInterfaceMerge.d.ts, 20, 1)) +>M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 6, 15), Decl(classAndInterfaceMerge.d.ts, 19, 1)) export interface C2 { } ->C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 17, 20), Decl(classAndInterfaceMerge.d.ts, 22, 18)) +>C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 16, 20), Decl(classAndInterfaceMerge.d.ts, 21, 18)) } diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.types b/tests/baselines/reference/classAndInterfaceMerge.d.types index baab121ca6e..2a7bbb86bed 100644 --- a/tests/baselines/reference/classAndInterfaceMerge.d.types +++ b/tests/baselines/reference/classAndInterfaceMerge.d.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts === - interface C { } >C : C diff --git a/tests/baselines/reference/classConstructorAccessibility.errors.txt b/tests/baselines/reference/classConstructorAccessibility.errors.txt index c79633ba33d..c05f57e22b9 100644 --- a/tests/baselines/reference/classConstructorAccessibility.errors.txt +++ b/tests/baselines/reference/classConstructorAccessibility.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(15,9): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(16,9): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(32,13): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(33,13): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(14,9): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(15,9): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(31,13): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(32,13): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts (4 errors) ==== - class C { public constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility.js b/tests/baselines/reference/classConstructorAccessibility.js index efc3f3c273c..46a548d0b54 100644 --- a/tests/baselines/reference/classConstructorAccessibility.js +++ b/tests/baselines/reference/classConstructorAccessibility.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility.ts] - class C { public constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility2.errors.txt b/tests/baselines/reference/classConstructorAccessibility2.errors.txt index 337e9787e5e..2bb111617cd 100644 --- a/tests/baselines/reference/classConstructorAccessibility2.errors.txt +++ b/tests/baselines/reference/classConstructorAccessibility2.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(32,24): error TS2675: Cannot extend a class 'BaseC'. Class constructor is marked as private. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(35,28): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(36,35): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(40,10): error TS2674: Constructor of class 'BaseB' is protected and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(41,10): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(31,24): error TS2675: Cannot extend a class 'BaseC'. Class constructor is marked as private. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(34,28): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(35,35): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(39,10): error TS2674: Constructor of class 'BaseB' is protected and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(40,10): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts (5 errors) ==== - class BaseA { public constructor(public x: number) { } createInstance() { new BaseA(1); } diff --git a/tests/baselines/reference/classConstructorAccessibility2.js b/tests/baselines/reference/classConstructorAccessibility2.js index 7c77d13dffb..7297af11a4e 100644 --- a/tests/baselines/reference/classConstructorAccessibility2.js +++ b/tests/baselines/reference/classConstructorAccessibility2.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility2.ts] - class BaseA { public constructor(public x: number) { } createInstance() { new BaseA(1); } diff --git a/tests/baselines/reference/classConstructorAccessibility3.errors.txt b/tests/baselines/reference/classConstructorAccessibility3.errors.txt index 1b96db289dc..57fc9f58c1f 100644 --- a/tests/baselines/reference/classConstructorAccessibility3.errors.txt +++ b/tests/baselines/reference/classConstructorAccessibility3.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(21,1): error TS2322: Type 'typeof Baz' is not assignable to type 'typeof Foo'. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(20,1): error TS2322: Type 'typeof Baz' is not assignable to type 'typeof Foo'. Cannot assign a 'protected' constructor type to a 'public' constructor type. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(22,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Foo'. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(21,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Foo'. Cannot assign a 'private' constructor type to a 'public' constructor type. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(28,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Baz'. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(27,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Baz'. Cannot assign a 'private' constructor type to a 'protected' constructor type. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts (3 errors) ==== - class Foo { constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility3.js b/tests/baselines/reference/classConstructorAccessibility3.js index acc7d38aa55..3e024970bcf 100644 --- a/tests/baselines/reference/classConstructorAccessibility3.js +++ b/tests/baselines/reference/classConstructorAccessibility3.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility3.ts] - class Foo { constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility4.js b/tests/baselines/reference/classConstructorAccessibility4.js index f6370729971..032d4f8c13d 100644 --- a/tests/baselines/reference/classConstructorAccessibility4.js +++ b/tests/baselines/reference/classConstructorAccessibility4.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility4.ts] - class A { private constructor() { } diff --git a/tests/baselines/reference/classConstructorAccessibility4.symbols b/tests/baselines/reference/classConstructorAccessibility4.symbols index 66a9bbfabfd..18edada13ca 100644 --- a/tests/baselines/reference/classConstructorAccessibility4.symbols +++ b/tests/baselines/reference/classConstructorAccessibility4.symbols @@ -1,18 +1,17 @@ === tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility4.ts === - class A { >A : Symbol(A, Decl(classConstructorAccessibility4.ts, 0, 0)) private constructor() { } method() { ->method : Symbol(A.method, Decl(classConstructorAccessibility4.ts, 2, 29)) +>method : Symbol(A.method, Decl(classConstructorAccessibility4.ts, 1, 29)) class B { ->B : Symbol(B, Decl(classConstructorAccessibility4.ts, 4, 14)) +>B : Symbol(B, Decl(classConstructorAccessibility4.ts, 3, 14)) method() { ->method : Symbol(B.method, Decl(classConstructorAccessibility4.ts, 5, 17)) +>method : Symbol(B.method, Decl(classConstructorAccessibility4.ts, 4, 17)) new A(); // OK >A : Symbol(A, Decl(classConstructorAccessibility4.ts, 0, 0)) @@ -20,34 +19,34 @@ class A { } class C extends A { // OK ->C : Symbol(C, Decl(classConstructorAccessibility4.ts, 9, 9)) +>C : Symbol(C, Decl(classConstructorAccessibility4.ts, 8, 9)) >A : Symbol(A, Decl(classConstructorAccessibility4.ts, 0, 0)) } } } class D { ->D : Symbol(D, Decl(classConstructorAccessibility4.ts, 14, 1)) +>D : Symbol(D, Decl(classConstructorAccessibility4.ts, 13, 1)) protected constructor() { } method() { ->method : Symbol(D.method, Decl(classConstructorAccessibility4.ts, 17, 31)) +>method : Symbol(D.method, Decl(classConstructorAccessibility4.ts, 16, 31)) class E { ->E : Symbol(E, Decl(classConstructorAccessibility4.ts, 19, 14)) +>E : Symbol(E, Decl(classConstructorAccessibility4.ts, 18, 14)) method() { ->method : Symbol(E.method, Decl(classConstructorAccessibility4.ts, 20, 17)) +>method : Symbol(E.method, Decl(classConstructorAccessibility4.ts, 19, 17)) new D(); // OK ->D : Symbol(D, Decl(classConstructorAccessibility4.ts, 14, 1)) +>D : Symbol(D, Decl(classConstructorAccessibility4.ts, 13, 1)) } } class F extends D { // OK ->F : Symbol(F, Decl(classConstructorAccessibility4.ts, 24, 9)) ->D : Symbol(D, Decl(classConstructorAccessibility4.ts, 14, 1)) +>F : Symbol(F, Decl(classConstructorAccessibility4.ts, 23, 9)) +>D : Symbol(D, Decl(classConstructorAccessibility4.ts, 13, 1)) } } } diff --git a/tests/baselines/reference/classConstructorAccessibility4.types b/tests/baselines/reference/classConstructorAccessibility4.types index 1eb5a25e220..46de7994792 100644 --- a/tests/baselines/reference/classConstructorAccessibility4.types +++ b/tests/baselines/reference/classConstructorAccessibility4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility4.ts === - class A { >A : A diff --git a/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt b/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt index 8882b9f0180..4f4bca4eb69 100644 --- a/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt +++ b/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt @@ -1,10 +1,9 @@ +tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(2,2): error TS2385: Overload signatures must all be public, private or protected. tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(3,2): error TS2385: Overload signatures must all be public, private or protected. -tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(4,2): error TS2385: Overload signatures must all be public, private or protected. -tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(12,2): error TS2385: Overload signatures must all be public, private or protected. +tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(11,2): error TS2385: Overload signatures must all be public, private or protected. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts (3 errors) ==== - class A { public constructor(a: boolean) // error ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/classConstructorOverloadsAccessibility.js b/tests/baselines/reference/classConstructorOverloadsAccessibility.js index 3914c29b785..7fef7443c62 100644 --- a/tests/baselines/reference/classConstructorOverloadsAccessibility.js +++ b/tests/baselines/reference/classConstructorOverloadsAccessibility.js @@ -1,5 +1,4 @@ //// [classConstructorOverloadsAccessibility.ts] - class A { public constructor(a: boolean) // error protected constructor(a: number) // error diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.js b/tests/baselines/reference/classExpressionWithStaticProperties3.js index 7bec5fca167..ca6f6608b75 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.js +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.js @@ -1,5 +1,4 @@ //// [classExpressionWithStaticProperties3.ts] - declare var console: any; const arr: {y(): number}[] = []; for (let i = 0; i < 3; i++) { diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols index ff9b7b0d311..2cf04ac05d3 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/classExpressionWithStaticProperties3.ts === - declare var console: any; ->console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 1, 11)) +>console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 0, 11)) const arr: {y(): number}[] = []; ->arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 2, 5)) ->y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 2, 12)) +>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5)) +>y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12)) for (let i = 0; i < 3; i++) { ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) arr.push(class C { >arr.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 4, 13)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13)) static x = i; ->x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 4, 22)) ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) +>x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 3, 22)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) static y = () => C.x * 2; ->y : Symbol(C.y, Decl(classExpressionWithStaticProperties3.ts, 5, 21)) ->C.x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 4, 22)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 4, 13)) ->x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 4, 22)) +>y : Symbol(C.y, Decl(classExpressionWithStaticProperties3.ts, 4, 21)) +>C.x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 3, 22)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13)) +>x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 3, 22)) }); } arr.forEach(C => console.log(C.y())); >arr.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5)) >forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 9, 12)) ->console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 1, 11)) ->C.y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 2, 12)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 9, 12)) ->y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 2, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 8, 12)) +>console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 0, 11)) +>C.y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 8, 12)) +>y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12)) diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.types b/tests/baselines/reference/classExpressionWithStaticProperties3.types index b7f6102c8b7..67823ea8340 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.types +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/classExpressionWithStaticProperties3.ts === - declare var console: any; >console : any diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js index 3993f18c0c7..0ac97e7a755 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js @@ -1,5 +1,4 @@ //// [classExpressionWithStaticPropertiesES63.ts] - declare var console: any; const arr: {y(): number}[] = []; for (let i = 0; i < 3; i++) { diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols index f1a7fa807f5..d39463b228c 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts === - declare var console: any; ->console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 11)) +>console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 0, 11)) const arr: {y(): number}[] = []; ->arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 5)) ->y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 12)) +>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5)) +>y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12)) for (let i = 0; i < 3; i++) { ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) arr.push(class C { >arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 13)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13)) static x = i; ->x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 22)) ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) +>x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 22)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) static y = () => C.x * 2; ->y : Symbol(C.y, Decl(classExpressionWithStaticPropertiesES63.ts, 5, 21)) ->C.x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 22)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 13)) ->x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 22)) +>y : Symbol(C.y, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 21)) +>C.x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 22)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13)) +>x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 22)) }); } arr.forEach(C => console.log(C.y())); >arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 9, 12)) ->console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 11)) ->C.y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 12)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 9, 12)) ->y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 8, 12)) +>console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 0, 11)) +>C.y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 8, 12)) +>y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12)) diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types index 3bc780785aa..5a948f54402 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types @@ -1,5 +1,4 @@ === tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts === - declare var console: any; >console : any diff --git a/tests/baselines/reference/classOrder2.errors.txt b/tests/baselines/reference/classOrder2.errors.txt index a1b8dc6346e..7b5547f678f 100644 --- a/tests/baselines/reference/classOrder2.errors.txt +++ b/tests/baselines/reference/classOrder2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/classOrder2.ts(2,17): error TS2690: A class must be declared after its base class. +tests/cases/compiler/classOrder2.ts(1,17): error TS2690: A class must be declared after its base class. ==== tests/cases/compiler/classOrder2.ts (1 errors) ==== - class A extends B { ~ !!! error TS2690: A class must be declared after its base class. diff --git a/tests/baselines/reference/classOrder2.js b/tests/baselines/reference/classOrder2.js index 897089b8b57..13ddfd8ae82 100644 --- a/tests/baselines/reference/classOrder2.js +++ b/tests/baselines/reference/classOrder2.js @@ -1,5 +1,4 @@ //// [classOrder2.ts] - class A extends B { foo() { this.bar(); } diff --git a/tests/baselines/reference/classStaticPropertyTypeGuard.js b/tests/baselines/reference/classStaticPropertyTypeGuard.js index 872f78db4c4..7b0a8fa0a79 100644 --- a/tests/baselines/reference/classStaticPropertyTypeGuard.js +++ b/tests/baselines/reference/classStaticPropertyTypeGuard.js @@ -1,5 +1,4 @@ //// [classStaticPropertyTypeGuard.ts] - // Repro from #8923 class A { diff --git a/tests/baselines/reference/classStaticPropertyTypeGuard.symbols b/tests/baselines/reference/classStaticPropertyTypeGuard.symbols index c4d2acd50b0..4823b85ccae 100644 --- a/tests/baselines/reference/classStaticPropertyTypeGuard.symbols +++ b/tests/baselines/reference/classStaticPropertyTypeGuard.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/classStaticPropertyTypeGuard.ts === - // Repro from #8923 class A { >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) private static _a: string | undefined; ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) public get a(): string { ->a : Symbol(A.a, Decl(classStaticPropertyTypeGuard.ts, 4, 42)) +>a : Symbol(A.a, Decl(classStaticPropertyTypeGuard.ts, 3, 42)) if (A._a) { ->A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) return A._a; // is possibly null or undefined. ->A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) } return A._a = 'helloworld'; ->A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) } } diff --git a/tests/baselines/reference/classStaticPropertyTypeGuard.types b/tests/baselines/reference/classStaticPropertyTypeGuard.types index f9bf8b68062..b0b6bb4d398 100644 --- a/tests/baselines/reference/classStaticPropertyTypeGuard.types +++ b/tests/baselines/reference/classStaticPropertyTypeGuard.types @@ -1,5 +1,4 @@ === tests/cases/compiler/classStaticPropertyTypeGuard.ts === - // Repro from #8923 class A { diff --git a/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt b/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt index a22fbb1e1d0..ecf7e5ed1dc 100644 --- a/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt +++ b/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(11,1): error TS2322: Type 'string' is not assignable to type 'boolean'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(12,1): error TS2322: Type 'number' is not assignable to type 'boolean'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(14,1): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(15,1): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(17,1): error TS2322: Type 'boolean' is not assignable to type 'string'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(18,1): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(10,1): error TS2322: Type 'string' is not assignable to type 'boolean'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(11,1): error TS2322: Type 'number' is not assignable to type 'boolean'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(13,1): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(14,1): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(16,1): error TS2322: Type 'boolean' is not assignable to type 'string'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(17,1): error TS2322: Type 'number' is not assignable to type 'string'. ==== tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts (6 errors) ==== - var BOOLEAN: boolean; var NUMBER: number; var STRING: string; diff --git a/tests/baselines/reference/commaOperatorInvalidAssignmentType.js b/tests/baselines/reference/commaOperatorInvalidAssignmentType.js index 9a16d4bbc28..0d6b9389cfc 100644 --- a/tests/baselines/reference/commaOperatorInvalidAssignmentType.js +++ b/tests/baselines/reference/commaOperatorInvalidAssignmentType.js @@ -1,5 +1,4 @@ //// [commaOperatorInvalidAssignmentType.ts] - var BOOLEAN: boolean; var NUMBER: number; var STRING: string; diff --git a/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt b/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt index a38fcd0741e..32e8464a195 100644 --- a/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt +++ b/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(7,5): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(13,9): error TS2322: Type 'T2' is not assignable to type 'T1'. +tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(6,5): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(12,9): error TS2322: Type 'T2' is not assignable to type 'T1'. ==== tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts (2 errors) ==== - //Expect to have compiler errors //Comma operator in fuction arguments and return function foo(x: number, y: string) { diff --git a/tests/baselines/reference/commaOperatorOtherInvalidOperation.js b/tests/baselines/reference/commaOperatorOtherInvalidOperation.js index 996b08e2ca0..d14dec67709 100644 --- a/tests/baselines/reference/commaOperatorOtherInvalidOperation.js +++ b/tests/baselines/reference/commaOperatorOtherInvalidOperation.js @@ -1,5 +1,4 @@ //// [commaOperatorOtherInvalidOperation.ts] - //Expect to have compiler errors //Comma operator in fuction arguments and return function foo(x: number, y: string) { diff --git a/tests/baselines/reference/commaOperatorOtherValidOperation.js b/tests/baselines/reference/commaOperatorOtherValidOperation.js index 3a08735a2ed..383b7c5058e 100644 --- a/tests/baselines/reference/commaOperatorOtherValidOperation.js +++ b/tests/baselines/reference/commaOperatorOtherValidOperation.js @@ -1,5 +1,4 @@ //// [commaOperatorOtherValidOperation.ts] - //Comma operator in for loop for (var i = 0, j = 10; i < j; i++, j--) { diff --git a/tests/baselines/reference/commaOperatorOtherValidOperation.symbols b/tests/baselines/reference/commaOperatorOtherValidOperation.symbols index b0ff23dc118..da65d20fc30 100644 --- a/tests/baselines/reference/commaOperatorOtherValidOperation.symbols +++ b/tests/baselines/reference/commaOperatorOtherValidOperation.symbols @@ -1,51 +1,50 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorOtherValidOperation.ts === - //Comma operator in for loop for (var i = 0, j = 10; i < j; i++, j--) ->i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 2, 8)) ->j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 2, 15)) ->i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 2, 8)) ->j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 2, 15)) ->i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 2, 8)) ->j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 2, 15)) +>i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 1, 8)) +>j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 1, 15)) +>i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 1, 8)) +>j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 1, 15)) +>i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 1, 8)) +>j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 1, 15)) { } //Comma operator in fuction arguments and return function foo(x: number, y: string) ->foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 4, 1)) ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 7, 13)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 7, 23)) +>foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 3, 1)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 6, 13)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 6, 23)) { return x, y; ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 7, 13)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 7, 23)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 6, 13)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 6, 23)) } var resultIsString = foo(1, "123"); ->resultIsString : Symbol(resultIsString, Decl(commaOperatorOtherValidOperation.ts, 11, 3)) ->foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 4, 1)) +>resultIsString : Symbol(resultIsString, Decl(commaOperatorOtherValidOperation.ts, 10, 3)) +>foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 3, 1)) //TypeParameters function foo1() ->foo1 : Symbol(foo1, Decl(commaOperatorOtherValidOperation.ts, 11, 35)) ->T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 14, 14)) ->T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 14, 17)) +>foo1 : Symbol(foo1, Decl(commaOperatorOtherValidOperation.ts, 10, 35)) +>T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 13, 14)) +>T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 13, 17)) { var x: T1; ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) ->T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 14, 14)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 15, 7)) +>T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 13, 14)) var y: T2; ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 17, 7)) ->T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 14, 17)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) +>T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 13, 17)) x, y; ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 17, 7)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 15, 7)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) var resultIsT1 = (y, x); ->resultIsT1 : Symbol(resultIsT1, Decl(commaOperatorOtherValidOperation.ts, 19, 7)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 17, 7)) ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) +>resultIsT1 : Symbol(resultIsT1, Decl(commaOperatorOtherValidOperation.ts, 18, 7)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 15, 7)) } diff --git a/tests/baselines/reference/commaOperatorOtherValidOperation.types b/tests/baselines/reference/commaOperatorOtherValidOperation.types index 2691a3384bd..71fc5853c9a 100644 --- a/tests/baselines/reference/commaOperatorOtherValidOperation.types +++ b/tests/baselines/reference/commaOperatorOtherValidOperation.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorOtherValidOperation.ts === - //Comma operator in for loop for (var i = 0, j = 10; i < j; i++, j--) >i : number diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js index d7b857f9f8f..522bbbe4e19 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandAnyType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols index ecd5a3932ba..ba9618a5ecf 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols @@ -1,78 +1,77 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandAnyType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is any ANY, ANY; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) BOOLEAN, ANY; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) NUMBER, ANY; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) STRING, ANY; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) OBJECT, ANY; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) //Return type is any var resultIsAny1 = (ANY, ANY); ->resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorWithSecondOperandAnyType.ts, 15, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorWithSecondOperandAnyType.ts, 14, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny2 = (BOOLEAN, ANY); ->resultIsAny2 : Symbol(resultIsAny2, Decl(commaOperatorWithSecondOperandAnyType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny2 : Symbol(resultIsAny2, Decl(commaOperatorWithSecondOperandAnyType.ts, 15, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny3 = (NUMBER, ANY); ->resultIsAny3 : Symbol(resultIsAny3, Decl(commaOperatorWithSecondOperandAnyType.ts, 17, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny3 : Symbol(resultIsAny3, Decl(commaOperatorWithSecondOperandAnyType.ts, 16, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny4 = (STRING, ANY); ->resultIsAny4 : Symbol(resultIsAny4, Decl(commaOperatorWithSecondOperandAnyType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny4 : Symbol(resultIsAny4, Decl(commaOperatorWithSecondOperandAnyType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny5 = (OBJECT, ANY); ->resultIsAny5 : Symbol(resultIsAny5, Decl(commaOperatorWithSecondOperandAnyType.ts, 19, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny5 : Symbol(resultIsAny5, Decl(commaOperatorWithSecondOperandAnyType.ts, 18, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) //Literal and expression var x: any; ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) 1, ANY; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) ++NUMBER, ANY; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) "string", [null, 1]; "string".charAt(0), [null, 1]; @@ -80,36 +79,36 @@ var x: any; >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) true, x("any"); ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) !BOOLEAN, x.doSomeThing(); ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) var resultIsAny6 = (1, ANY); ->resultIsAny6 : Symbol(resultIsAny6, Decl(commaOperatorWithSecondOperandAnyType.ts, 31, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny6 : Symbol(resultIsAny6, Decl(commaOperatorWithSecondOperandAnyType.ts, 30, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny7 = (++NUMBER, ANY); ->resultIsAny7 : Symbol(resultIsAny7, Decl(commaOperatorWithSecondOperandAnyType.ts, 32, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny7 : Symbol(resultIsAny7, Decl(commaOperatorWithSecondOperandAnyType.ts, 31, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny8 = ("string", null); ->resultIsAny8 : Symbol(resultIsAny8, Decl(commaOperatorWithSecondOperandAnyType.ts, 33, 3)) +>resultIsAny8 : Symbol(resultIsAny8, Decl(commaOperatorWithSecondOperandAnyType.ts, 32, 3)) var resultIsAny9 = ("string".charAt(0), undefined); ->resultIsAny9 : Symbol(resultIsAny9, Decl(commaOperatorWithSecondOperandAnyType.ts, 34, 3)) +>resultIsAny9 : Symbol(resultIsAny9, Decl(commaOperatorWithSecondOperandAnyType.ts, 33, 3)) >"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) var resultIsAny10 = (true, x("any")); ->resultIsAny10 : Symbol(resultIsAny10, Decl(commaOperatorWithSecondOperandAnyType.ts, 35, 3)) ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>resultIsAny10 : Symbol(resultIsAny10, Decl(commaOperatorWithSecondOperandAnyType.ts, 34, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) var resultIsAny11 = (!BOOLEAN, x.doSomeThing()); ->resultIsAny11 : Symbol(resultIsAny11, Decl(commaOperatorWithSecondOperandAnyType.ts, 36, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>resultIsAny11 : Symbol(resultIsAny11, Decl(commaOperatorWithSecondOperandAnyType.ts, 35, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types index b3695b74eea..e2535bd17ab 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandAnyType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js index 92996fe679d..dfaba1a93ca 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandBooleanType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols index 2ea892ad16e..9be885bf41c 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols @@ -1,111 +1,110 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandBooleanType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is boolean ANY, BOOLEAN; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) BOOLEAN, BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) NUMBER, BOOLEAN; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) STRING, BOOLEAN; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) OBJECT, BOOLEAN; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) //Return type is boolean var resultIsBoolean1 = (ANY, BOOLEAN); ->resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorWithSecondOperandBooleanType.ts, 15, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorWithSecondOperandBooleanType.ts, 14, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean2 = (BOOLEAN, BOOLEAN); ->resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(commaOperatorWithSecondOperandBooleanType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(commaOperatorWithSecondOperandBooleanType.ts, 15, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean3 = (NUMBER, BOOLEAN); ->resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(commaOperatorWithSecondOperandBooleanType.ts, 17, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(commaOperatorWithSecondOperandBooleanType.ts, 16, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean4 = (STRING, BOOLEAN); ->resultIsBoolean4 : Symbol(resultIsBoolean4, Decl(commaOperatorWithSecondOperandBooleanType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean4 : Symbol(resultIsBoolean4, Decl(commaOperatorWithSecondOperandBooleanType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean5 = (OBJECT, BOOLEAN); ->resultIsBoolean5 : Symbol(resultIsBoolean5, Decl(commaOperatorWithSecondOperandBooleanType.ts, 19, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean5 : Symbol(resultIsBoolean5, Decl(commaOperatorWithSecondOperandBooleanType.ts, 18, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) //Literal and expression null, BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) ANY = undefined, BOOLEAN; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) >undefined : Symbol(undefined) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) 1, true; ++NUMBER, true; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) [1, 2, 3], !BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) OBJECT = [1, 2, 3], BOOLEAN = false; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean6 = (null, BOOLEAN); ->resultIsBoolean6 : Symbol(resultIsBoolean6, Decl(commaOperatorWithSecondOperandBooleanType.ts, 29, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean6 : Symbol(resultIsBoolean6, Decl(commaOperatorWithSecondOperandBooleanType.ts, 28, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean7 = (ANY = undefined, BOOLEAN); ->resultIsBoolean7 : Symbol(resultIsBoolean7, Decl(commaOperatorWithSecondOperandBooleanType.ts, 30, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>resultIsBoolean7 : Symbol(resultIsBoolean7, Decl(commaOperatorWithSecondOperandBooleanType.ts, 29, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) >undefined : Symbol(undefined) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean8 = (1, true); ->resultIsBoolean8 : Symbol(resultIsBoolean8, Decl(commaOperatorWithSecondOperandBooleanType.ts, 31, 3)) +>resultIsBoolean8 : Symbol(resultIsBoolean8, Decl(commaOperatorWithSecondOperandBooleanType.ts, 30, 3)) var resultIsBoolean9 = (++NUMBER, true); ->resultIsBoolean9 : Symbol(resultIsBoolean9, Decl(commaOperatorWithSecondOperandBooleanType.ts, 32, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>resultIsBoolean9 : Symbol(resultIsBoolean9, Decl(commaOperatorWithSecondOperandBooleanType.ts, 31, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) var resultIsBoolean10 = ([1, 2, 3], !BOOLEAN); ->resultIsBoolean10 : Symbol(resultIsBoolean10, Decl(commaOperatorWithSecondOperandBooleanType.ts, 33, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean10 : Symbol(resultIsBoolean10, Decl(commaOperatorWithSecondOperandBooleanType.ts, 32, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean11 = (OBJECT = [1, 2, 3], BOOLEAN = false); ->resultIsBoolean11 : Symbol(resultIsBoolean11, Decl(commaOperatorWithSecondOperandBooleanType.ts, 34, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean11 : Symbol(resultIsBoolean11, Decl(commaOperatorWithSecondOperandBooleanType.ts, 33, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types index 64167f22e6c..6c791bdee2c 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandBooleanType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js index 45d38c9c9c5..b5b8887e749 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandNumberType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols index 3e6fdfd9ef8..bf5ff9437a3 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols @@ -1,115 +1,114 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandNumberType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is number ANY, NUMBER; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) BOOLEAN, NUMBER; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) NUMBER, NUMBER; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) STRING, NUMBER; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) OBJECT, NUMBER; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 5, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) //Return type is number var resultIsNumber1 = (ANY, NUMBER); ->resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorWithSecondOperandNumberType.ts, 15, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorWithSecondOperandNumberType.ts, 14, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber2 = (BOOLEAN, NUMBER); ->resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorWithSecondOperandNumberType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorWithSecondOperandNumberType.ts, 15, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber3 = (NUMBER, NUMBER); ->resultIsNumber3 : Symbol(resultIsNumber3, Decl(commaOperatorWithSecondOperandNumberType.ts, 17, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber3 : Symbol(resultIsNumber3, Decl(commaOperatorWithSecondOperandNumberType.ts, 16, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber4 = (STRING, NUMBER); ->resultIsNumber4 : Symbol(resultIsNumber4, Decl(commaOperatorWithSecondOperandNumberType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber4 : Symbol(resultIsNumber4, Decl(commaOperatorWithSecondOperandNumberType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber5 = (OBJECT, NUMBER); ->resultIsNumber5 : Symbol(resultIsNumber5, Decl(commaOperatorWithSecondOperandNumberType.ts, 19, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 5, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber5 : Symbol(resultIsNumber5, Decl(commaOperatorWithSecondOperandNumberType.ts, 18, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) //Literal and expression null, NUMBER; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) ANY = undefined, NUMBER; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) >undefined : Symbol(undefined) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) true, 1; BOOLEAN = false, 1; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) "", NUMBER = 1; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) STRING.trim(), NUMBER = 1; >STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) >trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber6 = (null, NUMBER); ->resultIsNumber6 : Symbol(resultIsNumber6, Decl(commaOperatorWithSecondOperandNumberType.ts, 29, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber6 : Symbol(resultIsNumber6, Decl(commaOperatorWithSecondOperandNumberType.ts, 28, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber7 = (ANY = undefined, NUMBER); ->resultIsNumber7 : Symbol(resultIsNumber7, Decl(commaOperatorWithSecondOperandNumberType.ts, 30, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>resultIsNumber7 : Symbol(resultIsNumber7, Decl(commaOperatorWithSecondOperandNumberType.ts, 29, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) >undefined : Symbol(undefined) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber8 = (true, 1); ->resultIsNumber8 : Symbol(resultIsNumber8, Decl(commaOperatorWithSecondOperandNumberType.ts, 31, 3)) +>resultIsNumber8 : Symbol(resultIsNumber8, Decl(commaOperatorWithSecondOperandNumberType.ts, 30, 3)) var resultIsNumber9 = (BOOLEAN = false, 1); ->resultIsNumber9 : Symbol(resultIsNumber9, Decl(commaOperatorWithSecondOperandNumberType.ts, 32, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>resultIsNumber9 : Symbol(resultIsNumber9, Decl(commaOperatorWithSecondOperandNumberType.ts, 31, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) var resultIsNumber10 = ("", NUMBER = 1); ->resultIsNumber10 : Symbol(resultIsNumber10, Decl(commaOperatorWithSecondOperandNumberType.ts, 33, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber10 : Symbol(resultIsNumber10, Decl(commaOperatorWithSecondOperandNumberType.ts, 32, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber11 = (STRING.trim(), NUMBER = 1); ->resultIsNumber11 : Symbol(resultIsNumber11, Decl(commaOperatorWithSecondOperandNumberType.ts, 34, 3)) +>resultIsNumber11 : Symbol(resultIsNumber11, Decl(commaOperatorWithSecondOperandNumberType.ts, 33, 3)) >STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) >trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types index 8727665c59b..2a53a23c4e0 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandNumberType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js index dd269d88217..ef814863934 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandObjectType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols index cfaab330b46..6df26708078 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols @@ -1,122 +1,121 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandObjectType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class CLASS { ->CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 19)) +>CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) num: number; ->num : Symbol(CLASS.num, Decl(commaOperatorWithSecondOperandObjectType.ts, 7, 13)) +>num : Symbol(CLASS.num, Decl(commaOperatorWithSecondOperandObjectType.ts, 6, 13)) } //The second operand type is Object ANY, OBJECT; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) BOOLEAN, OBJECT; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) NUMBER, OBJECT; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) STRING, OBJECT; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) OBJECT, OBJECT; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) //Return type is Object var resultIsObject1 = (ANY, OBJECT); ->resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorWithSecondOperandObjectType.ts, 19, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorWithSecondOperandObjectType.ts, 18, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject2 = (BOOLEAN, OBJECT); ->resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorWithSecondOperandObjectType.ts, 20, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorWithSecondOperandObjectType.ts, 19, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject3 = (NUMBER, OBJECT); ->resultIsObject3 : Symbol(resultIsObject3, Decl(commaOperatorWithSecondOperandObjectType.ts, 21, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject3 : Symbol(resultIsObject3, Decl(commaOperatorWithSecondOperandObjectType.ts, 20, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject4 = (STRING, OBJECT); ->resultIsObject4 : Symbol(resultIsObject4, Decl(commaOperatorWithSecondOperandObjectType.ts, 22, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject4 : Symbol(resultIsObject4, Decl(commaOperatorWithSecondOperandObjectType.ts, 21, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject5 = (OBJECT, OBJECT); ->resultIsObject5 : Symbol(resultIsObject5, Decl(commaOperatorWithSecondOperandObjectType.ts, 23, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject5 : Symbol(resultIsObject5, Decl(commaOperatorWithSecondOperandObjectType.ts, 22, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) //Literal and expression null, OBJECT ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ANY = null, OBJECT ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) true, {} !BOOLEAN, [] ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) "string", new Date() >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) STRING.toLowerCase(), new CLASS() >STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 19)) +>CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) var resultIsObject6 = (null, OBJECT); ->resultIsObject6 : Symbol(resultIsObject6, Decl(commaOperatorWithSecondOperandObjectType.ts, 33, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject6 : Symbol(resultIsObject6, Decl(commaOperatorWithSecondOperandObjectType.ts, 32, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject7 = (ANY = null, OBJECT); ->resultIsObject7 : Symbol(resultIsObject7, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject7 : Symbol(resultIsObject7, Decl(commaOperatorWithSecondOperandObjectType.ts, 33, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject8 = (true, {}); ->resultIsObject8 : Symbol(resultIsObject8, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 3)) +>resultIsObject8 : Symbol(resultIsObject8, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 3)) var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" }); ->resultIsObject9 : Symbol(resultIsObject9, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) ->a : Symbol(a, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 34)) ->b : Symbol(b, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 40)) +>resultIsObject9 : Symbol(resultIsObject9, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>a : Symbol(a, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 34)) +>b : Symbol(b, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 40)) var resultIsObject10 = ("string", new Date()); ->resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3)) +>resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsObject11 = (STRING.toLowerCase(), new CLASS()); ->resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 38, 3)) +>resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3)) >STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 19)) +>CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types index 493d97d6454..15d9f074da5 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandObjectType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js index f3f19563817..412e9e83121 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandStringType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols index d4f5873f493..2d9fc665a81 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols @@ -1,121 +1,120 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandStringType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsString: string; ->resultIsString : Symbol(resultIsString, Decl(commaOperatorWithSecondOperandStringType.ts, 7, 3)) +>resultIsString : Symbol(resultIsString, Decl(commaOperatorWithSecondOperandStringType.ts, 6, 3)) //The second operand is string ANY, STRING; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) BOOLEAN, STRING; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) NUMBER, STRING; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) STRING, STRING; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) OBJECT, STRING; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) //Return type is string var resultIsString1 = (ANY, STRING); ->resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorWithSecondOperandStringType.ts, 17, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorWithSecondOperandStringType.ts, 16, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString2 = (BOOLEAN, STRING); ->resultIsString2 : Symbol(resultIsString2, Decl(commaOperatorWithSecondOperandStringType.ts, 18, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString2 : Symbol(resultIsString2, Decl(commaOperatorWithSecondOperandStringType.ts, 17, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString3 = (NUMBER, STRING); ->resultIsString3 : Symbol(resultIsString3, Decl(commaOperatorWithSecondOperandStringType.ts, 19, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString3 : Symbol(resultIsString3, Decl(commaOperatorWithSecondOperandStringType.ts, 18, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString4 = (STRING, STRING); ->resultIsString4 : Symbol(resultIsString4, Decl(commaOperatorWithSecondOperandStringType.ts, 20, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString4 : Symbol(resultIsString4, Decl(commaOperatorWithSecondOperandStringType.ts, 19, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString5 = (OBJECT, STRING); ->resultIsString5 : Symbol(resultIsString5, Decl(commaOperatorWithSecondOperandStringType.ts, 21, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString5 : Symbol(resultIsString5, Decl(commaOperatorWithSecondOperandStringType.ts, 20, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) //Literal and expression null, STRING; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) ANY = new Date(), STRING; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) true, ""; BOOLEAN == undefined, ""; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) >undefined : Symbol(undefined) ["a", "b"], NUMBER.toString(); >NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) OBJECT = new Object, STRING + "string"; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString6 = (null, STRING); ->resultIsString6 : Symbol(resultIsString6, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString6 : Symbol(resultIsString6, Decl(commaOperatorWithSecondOperandStringType.ts, 30, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString7 = (ANY = new Date(), STRING); ->resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 32, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString8 = (true, ""); ->resultIsString8 : Symbol(resultIsString8, Decl(commaOperatorWithSecondOperandStringType.ts, 33, 3)) +>resultIsString8 : Symbol(resultIsString8, Decl(commaOperatorWithSecondOperandStringType.ts, 32, 3)) var resultIsString9 = (BOOLEAN == undefined, ""); ->resultIsString9 : Symbol(resultIsString9, Decl(commaOperatorWithSecondOperandStringType.ts, 34, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>resultIsString9 : Symbol(resultIsString9, Decl(commaOperatorWithSecondOperandStringType.ts, 33, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) >undefined : Symbol(undefined) var resultIsString10 = (["a", "b"], NUMBER.toString()); ->resultIsString10 : Symbol(resultIsString10, Decl(commaOperatorWithSecondOperandStringType.ts, 35, 3)) +>resultIsString10 : Symbol(resultIsString10, Decl(commaOperatorWithSecondOperandStringType.ts, 34, 3)) >NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var resultIsString11 = (new Object, STRING + "string"); ->resultIsString11 : Symbol(resultIsString11, Decl(commaOperatorWithSecondOperandStringType.ts, 36, 3)) +>resultIsString11 : Symbol(resultIsString11, Decl(commaOperatorWithSecondOperandStringType.ts, 35, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types index af5b7d2cb06..ca0cb475362 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandStringType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.js b/tests/baselines/reference/commaOperatorsMultipleOperators.js index 5157eb2c8ff..15d93c1f18c 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.js +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.js @@ -1,5 +1,4 @@ //// [commaOperatorsMultipleOperators.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols index bc1953709c2..3a580bc49e9 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols @@ -1,95 +1,94 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorsMultipleOperators.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Expected: work well ANY, BOOLEAN, NUMBER; ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) BOOLEAN, NUMBER, STRING; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) NUMBER, STRING, OBJECT; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) STRING, OBJECT, ANY; ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) OBJECT, ANY, BOOLEAN; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) //Results should have the same type as the third operand var resultIsAny1 = (STRING, OBJECT, ANY); ->resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorsMultipleOperators.ts, 15, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorsMultipleOperators.ts, 14, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) var resultIsBoolean1 = (OBJECT, ANY, BOOLEAN); ->resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorsMultipleOperators.ts, 16, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorsMultipleOperators.ts, 15, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) var resultIsNumber1 = (ANY, BOOLEAN, NUMBER); ->resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorsMultipleOperators.ts, 17, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorsMultipleOperators.ts, 16, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) var resultIsString1 = (BOOLEAN, NUMBER, STRING); ->resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorsMultipleOperators.ts, 18, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorsMultipleOperators.ts, 17, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) var resultIsObject1 = (NUMBER, STRING, OBJECT); ->resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorsMultipleOperators.ts, 19, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) +>resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorsMultipleOperators.ts, 18, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) //Literal and expression null, true, 1; ++NUMBER, STRING.charAt(0), new Object(); ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) >STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsNumber2 = (null, true, 1); ->resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorsMultipleOperators.ts, 25, 3)) +>resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorsMultipleOperators.ts, 24, 3)) var resultIsObject2 = (++NUMBER, STRING.charAt(0), new Object()); ->resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorsMultipleOperators.ts, 26, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorsMultipleOperators.ts, 25, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) >STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.types b/tests/baselines/reference/commaOperatorsMultipleOperators.types index a0d5b382c59..99796e36cb7 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.types +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorsMultipleOperators.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.js b/tests/baselines/reference/commentEmitAtEndOfFile1.js index cada7754002..1be031fa84a 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.js +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.js @@ -1,5 +1,4 @@ //// [commentEmitAtEndOfFile1.ts] - // test var f = '' // test #2 diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols index cb06d088307..1fc0ad09553 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/commentEmitAtEndOfFile1.ts === - // test var f = '' ->f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 2, 3)) +>f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 1, 3)) // test #2 module foo { ->foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 2, 10)) +>foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 1, 10)) function bar() { } ->bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 4, 12)) +>bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 3, 12)) } // test #3 module empty { ->empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 6, 1)) +>empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 5, 1)) } // test #4 diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.types b/tests/baselines/reference/commentEmitAtEndOfFile1.types index 2071e98af8d..e6bd6b162fe 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.types +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentEmitAtEndOfFile1.ts === - // test var f = '' >f : string diff --git a/tests/baselines/reference/commentOnExpressionStatement1.js b/tests/baselines/reference/commentOnExpressionStatement1.js index 713c079bcf2..9a15ab94bff 100644 --- a/tests/baselines/reference/commentOnExpressionStatement1.js +++ b/tests/baselines/reference/commentOnExpressionStatement1.js @@ -1,5 +1,4 @@ //// [commentOnExpressionStatement1.ts] - 1 + 1; // Comment. //// [commentOnExpressionStatement1.js] diff --git a/tests/baselines/reference/commentOnExpressionStatement1.symbols b/tests/baselines/reference/commentOnExpressionStatement1.symbols index f78660f0344..58d45470ca5 100644 --- a/tests/baselines/reference/commentOnExpressionStatement1.symbols +++ b/tests/baselines/reference/commentOnExpressionStatement1.symbols @@ -1,4 +1,3 @@ === tests/cases/compiler/commentOnExpressionStatement1.ts === - -No type information for this code.1 + 1; // Comment. +1 + 1; // Comment. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/commentOnExpressionStatement1.types b/tests/baselines/reference/commentOnExpressionStatement1.types index 39141c8d52e..9eb15e394ca 100644 --- a/tests/baselines/reference/commentOnExpressionStatement1.types +++ b/tests/baselines/reference/commentOnExpressionStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentOnExpressionStatement1.ts === - 1 + 1; // Comment. >1 + 1 : number >1 : 1 diff --git a/tests/baselines/reference/commentOnIfStatement1.js b/tests/baselines/reference/commentOnIfStatement1.js index 521bc6ff1be..cad61e5ce3a 100644 --- a/tests/baselines/reference/commentOnIfStatement1.js +++ b/tests/baselines/reference/commentOnIfStatement1.js @@ -1,5 +1,4 @@ //// [commentOnIfStatement1.ts] - // Test if (true) { } diff --git a/tests/baselines/reference/commentOnIfStatement1.symbols b/tests/baselines/reference/commentOnIfStatement1.symbols index 03f357c8ccf..cc1fa728c4a 100644 --- a/tests/baselines/reference/commentOnIfStatement1.symbols +++ b/tests/baselines/reference/commentOnIfStatement1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/commentOnIfStatement1.ts === - -No type information for this code.// Test +// Test No type information for this code.if (true) { No type information for this code.} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/commentOnIfStatement1.types b/tests/baselines/reference/commentOnIfStatement1.types index 4f7fcdddd22..c1bdee6af70 100644 --- a/tests/baselines/reference/commentOnIfStatement1.types +++ b/tests/baselines/reference/commentOnIfStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentOnIfStatement1.ts === - // Test if (true) { >true : true diff --git a/tests/baselines/reference/commentsAtEndOfFile1.js b/tests/baselines/reference/commentsAtEndOfFile1.js index d93dded59b0..2d4dae39e6b 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.js +++ b/tests/baselines/reference/commentsAtEndOfFile1.js @@ -1,5 +1,4 @@ //// [commentsAtEndOfFile1.ts] - Input: ; //Testing two diff --git a/tests/baselines/reference/commentsAtEndOfFile1.symbols b/tests/baselines/reference/commentsAtEndOfFile1.symbols index d35b4f251f6..c09a435f1a7 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.symbols +++ b/tests/baselines/reference/commentsAtEndOfFile1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/commentsAtEndOfFile1.ts === - -No type information for this code.Input: +Input: No type information for this code.; No type information for this code.//Testing two No type information for this code. diff --git a/tests/baselines/reference/commentsAtEndOfFile1.types b/tests/baselines/reference/commentsAtEndOfFile1.types index 71eb367738b..6bac6757061 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.types +++ b/tests/baselines/reference/commentsAtEndOfFile1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsAtEndOfFile1.ts === - Input: >Input : any diff --git a/tests/baselines/reference/commentsClass.js b/tests/baselines/reference/commentsClass.js index 574fc025227..49fda992b08 100644 --- a/tests/baselines/reference/commentsClass.js +++ b/tests/baselines/reference/commentsClass.js @@ -1,5 +1,4 @@ //// [commentsClass.ts] - /** This is class c2 without constuctor*/ class c2 { } // trailing comment1 diff --git a/tests/baselines/reference/commentsClass.symbols b/tests/baselines/reference/commentsClass.symbols index 9364dc50b02..901cca58d0e 100644 --- a/tests/baselines/reference/commentsClass.symbols +++ b/tests/baselines/reference/commentsClass.symbols @@ -1,112 +1,111 @@ === tests/cases/compiler/commentsClass.ts === - /** This is class c2 without constuctor*/ class c2 { >c2 : Symbol(c2, Decl(commentsClass.ts, 0, 0)) } // trailing comment1 var i2 = new c2(); ->i2 : Symbol(i2, Decl(commentsClass.ts, 4, 3)) +>i2 : Symbol(i2, Decl(commentsClass.ts, 3, 3)) >c2 : Symbol(c2, Decl(commentsClass.ts, 0, 0)) var i2_c = c2; ->i2_c : Symbol(i2_c, Decl(commentsClass.ts, 5, 3)) +>i2_c : Symbol(i2_c, Decl(commentsClass.ts, 4, 3)) >c2 : Symbol(c2, Decl(commentsClass.ts, 0, 0)) class c3 { ->c3 : Symbol(c3, Decl(commentsClass.ts, 5, 14)) +>c3 : Symbol(c3, Decl(commentsClass.ts, 4, 14)) /** Constructor comment*/ constructor() { } // trailing comment of constructor } /* trailing comment 2 */ var i3 = new c3(); ->i3 : Symbol(i3, Decl(commentsClass.ts, 11, 3)) ->c3 : Symbol(c3, Decl(commentsClass.ts, 5, 14)) +>i3 : Symbol(i3, Decl(commentsClass.ts, 10, 3)) +>c3 : Symbol(c3, Decl(commentsClass.ts, 4, 14)) var i3_c = c3; ->i3_c : Symbol(i3_c, Decl(commentsClass.ts, 12, 3)) ->c3 : Symbol(c3, Decl(commentsClass.ts, 5, 14)) +>i3_c : Symbol(i3_c, Decl(commentsClass.ts, 11, 3)) +>c3 : Symbol(c3, Decl(commentsClass.ts, 4, 14)) /** Class comment*/ class c4 { ->c4 : Symbol(c4, Decl(commentsClass.ts, 12, 14)) +>c4 : Symbol(c4, Decl(commentsClass.ts, 11, 14)) /** Constructor comment*/ constructor() { } /* trailing comment of constructor 2*/ } var i4 = new c4(); ->i4 : Symbol(i4, Decl(commentsClass.ts, 19, 3)) ->c4 : Symbol(c4, Decl(commentsClass.ts, 12, 14)) +>i4 : Symbol(i4, Decl(commentsClass.ts, 18, 3)) +>c4 : Symbol(c4, Decl(commentsClass.ts, 11, 14)) var i4_c = c4; ->i4_c : Symbol(i4_c, Decl(commentsClass.ts, 20, 3)) ->c4 : Symbol(c4, Decl(commentsClass.ts, 12, 14)) +>i4_c : Symbol(i4_c, Decl(commentsClass.ts, 19, 3)) +>c4 : Symbol(c4, Decl(commentsClass.ts, 11, 14)) /** Class with statics*/ class c5 { ->c5 : Symbol(c5, Decl(commentsClass.ts, 20, 14)) +>c5 : Symbol(c5, Decl(commentsClass.ts, 19, 14)) static s1: number; ->s1 : Symbol(c5.s1, Decl(commentsClass.ts, 22, 10)) +>s1 : Symbol(c5.s1, Decl(commentsClass.ts, 21, 10)) } var i5 = new c5(); ->i5 : Symbol(i5, Decl(commentsClass.ts, 25, 3)) ->c5 : Symbol(c5, Decl(commentsClass.ts, 20, 14)) +>i5 : Symbol(i5, Decl(commentsClass.ts, 24, 3)) +>c5 : Symbol(c5, Decl(commentsClass.ts, 19, 14)) var i5_c = c5; ->i5_c : Symbol(i5_c, Decl(commentsClass.ts, 26, 3)) ->c5 : Symbol(c5, Decl(commentsClass.ts, 20, 14)) +>i5_c : Symbol(i5_c, Decl(commentsClass.ts, 25, 3)) +>c5 : Symbol(c5, Decl(commentsClass.ts, 19, 14)) /// class with statics and constructor class c6 { /// class with statics and constructor2 ->c6 : Symbol(c6, Decl(commentsClass.ts, 26, 14)) +>c6 : Symbol(c6, Decl(commentsClass.ts, 25, 14)) /// s1 comment static s1: number; /// s1 comment2 ->s1 : Symbol(c6.s1, Decl(commentsClass.ts, 29, 10)) +>s1 : Symbol(c6.s1, Decl(commentsClass.ts, 28, 10)) /// constructor comment constructor() { /// constructor comment2 } } var i6 = new c6(); ->i6 : Symbol(i6, Decl(commentsClass.ts, 36, 3)) ->c6 : Symbol(c6, Decl(commentsClass.ts, 26, 14)) +>i6 : Symbol(i6, Decl(commentsClass.ts, 35, 3)) +>c6 : Symbol(c6, Decl(commentsClass.ts, 25, 14)) var i6_c = c6; ->i6_c : Symbol(i6_c, Decl(commentsClass.ts, 37, 3)) ->c6 : Symbol(c6, Decl(commentsClass.ts, 26, 14)) +>i6_c : Symbol(i6_c, Decl(commentsClass.ts, 36, 3)) +>c6 : Symbol(c6, Decl(commentsClass.ts, 25, 14)) // class with statics and constructor class c7 { ->c7 : Symbol(c7, Decl(commentsClass.ts, 37, 14)) +>c7 : Symbol(c7, Decl(commentsClass.ts, 36, 14)) // s1 comment static s1: number; ->s1 : Symbol(c7.s1, Decl(commentsClass.ts, 40, 10)) +>s1 : Symbol(c7.s1, Decl(commentsClass.ts, 39, 10)) // constructor comment constructor() { } } var i7 = new c7(); ->i7 : Symbol(i7, Decl(commentsClass.ts, 47, 3)) ->c7 : Symbol(c7, Decl(commentsClass.ts, 37, 14)) +>i7 : Symbol(i7, Decl(commentsClass.ts, 46, 3)) +>c7 : Symbol(c7, Decl(commentsClass.ts, 36, 14)) var i7_c = c7; ->i7_c : Symbol(i7_c, Decl(commentsClass.ts, 48, 3)) ->c7 : Symbol(c7, Decl(commentsClass.ts, 37, 14)) +>i7_c : Symbol(i7_c, Decl(commentsClass.ts, 47, 3)) +>c7 : Symbol(c7, Decl(commentsClass.ts, 36, 14)) /** class with statics and constructor */ class c8 { ->c8 : Symbol(c8, Decl(commentsClass.ts, 48, 14)) +>c8 : Symbol(c8, Decl(commentsClass.ts, 47, 14)) /** s1 comment */ static s1: number; /** s1 comment2 */ ->s1 : Symbol(c8.s1, Decl(commentsClass.ts, 52, 10)) +>s1 : Symbol(c8.s1, Decl(commentsClass.ts, 51, 10)) /** constructor comment */ @@ -116,15 +115,15 @@ class c8 { } } var i8 = new c8(); ->i8 : Symbol(i8, Decl(commentsClass.ts, 62, 3)) ->c8 : Symbol(c8, Decl(commentsClass.ts, 48, 14)) +>i8 : Symbol(i8, Decl(commentsClass.ts, 61, 3)) +>c8 : Symbol(c8, Decl(commentsClass.ts, 47, 14)) var i8_c = c8; ->i8_c : Symbol(i8_c, Decl(commentsClass.ts, 63, 3)) ->c8 : Symbol(c8, Decl(commentsClass.ts, 48, 14)) +>i8_c : Symbol(i8_c, Decl(commentsClass.ts, 62, 3)) +>c8 : Symbol(c8, Decl(commentsClass.ts, 47, 14)) class c9 { ->c9 : Symbol(c9, Decl(commentsClass.ts, 63, 14)) +>c9 : Symbol(c9, Decl(commentsClass.ts, 62, 14)) constructor() { /// This is some detached comment diff --git a/tests/baselines/reference/commentsClass.types b/tests/baselines/reference/commentsClass.types index a4aca2ba15b..77ebc3a336a 100644 --- a/tests/baselines/reference/commentsClass.types +++ b/tests/baselines/reference/commentsClass.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsClass.ts === - /** This is class c2 without constuctor*/ class c2 { >c2 : c2 diff --git a/tests/baselines/reference/commentsClassMembers.js b/tests/baselines/reference/commentsClassMembers.js index dacbde7a276..9953e77ab7e 100644 --- a/tests/baselines/reference/commentsClassMembers.js +++ b/tests/baselines/reference/commentsClassMembers.js @@ -1,5 +1,4 @@ //// [commentsClassMembers.ts] - /** This is comment for c1*/ class c1 { /** p1 is property of c1*/ diff --git a/tests/baselines/reference/commentsClassMembers.symbols b/tests/baselines/reference/commentsClassMembers.symbols index 4cbf1292c10..f78523f638d 100644 --- a/tests/baselines/reference/commentsClassMembers.symbols +++ b/tests/baselines/reference/commentsClassMembers.symbols @@ -1,706 +1,705 @@ === tests/cases/compiler/commentsClassMembers.ts === - /** This is comment for c1*/ class c1 { >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) /** p1 is property of c1*/ public p1: number; ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) /** sum with property*/ public p2(/** number to add*/b: number) { ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 6, 14)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 5, 14)) return this.p1 + b; ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 6, 14)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 5, 14)) } /* trailing comment of method*/ /** getter property*/ public get p3() { ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) return this.p2(this.p1); ->this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) }// trailing comment Getter /** setter property*/ public set p3(/** this is value*/value: number) { ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 14, 18)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 13, 18)) this.p1 = this.p2(value); ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 14, 18)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 13, 18)) }// trailing comment Setter /** pp1 is property of c1*/ private pp1: number; ->pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) /** sum with property*/ private pp2(/** number to add*/b: number) { ->pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 20, 16)) +>pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 19, 16)) return this.p1 + b; ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 20, 16)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 19, 16)) } // trailing comment of method /** getter property*/ private get pp3() { ->pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 22, 5), Decl(commentsClassMembers.ts, 26, 5)) +>pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 21, 5), Decl(commentsClassMembers.ts, 25, 5)) return this.pp2(this.pp1); ->this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) +>this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) ->this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) +>this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) } /** setter property*/ private set pp3( /** this is value*/value: number) { ->pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 22, 5), Decl(commentsClassMembers.ts, 26, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 28, 20)) +>pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 21, 5), Decl(commentsClassMembers.ts, 25, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 27, 20)) this.pp1 = this.pp2(value); ->this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) ->this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) +>pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) +>this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 28, 20)) +>pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 27, 20)) } /** Constructor method*/ constructor() { } /** s1 is static property of c1*/ static s1: number; ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) /** static sum with property*/ static s2(/** number to add*/b: number) { ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 37, 14)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 36, 14)) return c1.s1 + b; ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 37, 14)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 36, 14)) } /** static getter property*/ static get s3() { ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) return c1.s2(c1.s1); ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) } /*trailing comment 1 getter*/ /** setter property*/ static set s3( /** this is value*/value: number) { ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 45, 18)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 44, 18)) c1.s1 = c1.s2(value); ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 45, 18)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 44, 18)) }/*trailing comment 2 */ /*setter*/ public nc_p1: number; ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) public nc_p2(b: number) { ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 49, 17)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 48, 17)) return this.nc_p1 + b; ->this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 49, 17)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 48, 17)) } public get nc_p3() { ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) return this.nc_p2(this.nc_p1); ->this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) } public set nc_p3(value: number) { ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 55, 21)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 54, 21)) this.nc_p1 = this.nc_p2(value); ->this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) ->this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) +>this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 55, 21)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 54, 21)) } private nc_pp1: number; ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) private nc_pp2(b: number) { ->nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 59, 19)) +>nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 58, 19)) return this.nc_pp1 + b; ->this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 59, 19)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 58, 19)) } private get nc_pp3() { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 61, 5), Decl(commentsClassMembers.ts, 64, 5)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 60, 5), Decl(commentsClassMembers.ts, 63, 5)) return this.nc_pp2(this.nc_pp1); ->this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) +>this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) ->this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) +>this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) } private set nc_pp3(value: number) { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 61, 5), Decl(commentsClassMembers.ts, 64, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 65, 23)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 60, 5), Decl(commentsClassMembers.ts, 63, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 64, 23)) this.nc_pp1 = this.nc_pp2(value); ->this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) ->this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) +>this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 65, 23)) +>nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 64, 23)) } static nc_s1: number; ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) static nc_s2(b: number) { ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 69, 17)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 68, 17)) return c1.nc_s1 + b; ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 69, 17)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 68, 17)) } static get nc_s3() { ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) return c1.nc_s2(c1.nc_s1); ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) } static set nc_s3(value: number) { ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 75, 21)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 74, 21)) c1.nc_s1 = c1.nc_s2(value); ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 75, 21)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 74, 21)) } // p1 is property of c1 public a_p1: number; ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) // sum with property public a_p2(b: number) { ->a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 82, 16)) +>a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 81, 16)) return this.a_p1 + b; ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 82, 16)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 81, 16)) } // getter property public get a_p3() { ->a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 84, 5), Decl(commentsClassMembers.ts, 88, 5)) +>a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 83, 5), Decl(commentsClassMembers.ts, 87, 5)) return this.a_p2(this.a_p1); ->this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) +>this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) } // setter property public set a_p3(value: number) { ->a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 84, 5), Decl(commentsClassMembers.ts, 88, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 90, 20)) +>a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 83, 5), Decl(commentsClassMembers.ts, 87, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 89, 20)) this.a_p1 = this.a_p2(value); ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) ->this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) +>this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 90, 20)) +>a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 89, 20)) } // pp1 is property of c1 private a_pp1: number; ->a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) // sum with property private a_pp2(b: number) { ->a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 96, 18)) +>a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 95, 18)) return this.a_p1 + b; ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 96, 18)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 95, 18)) } // getter property private get a_pp3() { ->a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 98, 5), Decl(commentsClassMembers.ts, 102, 5)) +>a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 97, 5), Decl(commentsClassMembers.ts, 101, 5)) return this.a_pp2(this.a_pp1); ->this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) +>this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) ->this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) +>this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) } // setter property private set a_pp3(value: number) { ->a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 98, 5), Decl(commentsClassMembers.ts, 102, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 104, 22)) +>a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 97, 5), Decl(commentsClassMembers.ts, 101, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 103, 22)) this.a_pp1 = this.a_pp2(value); ->this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) ->this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) +>a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) +>this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 104, 22)) +>a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 103, 22)) } // s1 is static property of c1 static a_s1: number; ->a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) +>a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) // static sum with property static a_s2(b: number) { ->a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 109, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 111, 16)) +>a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 108, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 110, 16)) return c1.a_s1 + b; ->c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) +>c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 111, 16)) +>a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 110, 16)) } // static getter property static get a_s3() { ->a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 113, 5), Decl(commentsClassMembers.ts, 117, 5)) +>a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 112, 5), Decl(commentsClassMembers.ts, 116, 5)) return c1.s2(c1.s1); ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) } // setter property static set a_s3(value: number) { ->a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 113, 5), Decl(commentsClassMembers.ts, 117, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 120, 20)) +>a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 112, 5), Decl(commentsClassMembers.ts, 116, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 119, 20)) c1.a_s1 = c1.a_s2(value); ->c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) +>c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) ->c1.a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 109, 24)) +>a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) +>c1.a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 108, 24)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 109, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 120, 20)) +>a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 108, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 119, 20)) } /** p1 is property of c1 */ public b_p1: number; ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) /** sum with property */ public b_p2(b: number) { ->b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 127, 16)) +>b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 126, 16)) return this.b_p1 + b; ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 127, 16)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 126, 16)) } /** getter property */ public get b_p3() { ->b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 129, 5), Decl(commentsClassMembers.ts, 133, 5)) +>b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 128, 5), Decl(commentsClassMembers.ts, 132, 5)) return this.b_p2(this.b_p1); ->this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) +>this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) } /** setter property */ public set b_p3(value: number) { ->b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 129, 5), Decl(commentsClassMembers.ts, 133, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 135, 20)) +>b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 128, 5), Decl(commentsClassMembers.ts, 132, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 134, 20)) this.b_p1 = this.b_p2(value); ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) ->this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) +>this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 135, 20)) +>b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 134, 20)) } /** pp1 is property of c1 */ private b_pp1: number; ->b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) /** sum with property */ private b_pp2(b: number) { ->b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 141, 18)) +>b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 140, 18)) return this.b_p1 + b; ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 141, 18)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 140, 18)) } /** getter property */ private get b_pp3() { ->b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 143, 5), Decl(commentsClassMembers.ts, 147, 5)) +>b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 142, 5), Decl(commentsClassMembers.ts, 146, 5)) return this.b_pp2(this.b_pp1); ->this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) +>this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) ->this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) +>this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) } /** setter property */ private set b_pp3(value: number) { ->b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 143, 5), Decl(commentsClassMembers.ts, 147, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 149, 22)) +>b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 142, 5), Decl(commentsClassMembers.ts, 146, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 148, 22)) this.b_pp1 = this.b_pp2(value); ->this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) ->this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) +>b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) +>this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 149, 22)) +>b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 148, 22)) } /** s1 is static property of c1 */ static b_s1: number; ->b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) +>b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) /** static sum with property */ static b_s2(b: number) { ->b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 154, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 156, 16)) +>b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 153, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 155, 16)) return c1.b_s1 + b; ->c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) +>c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 156, 16)) +>b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 155, 16)) } /** static getter property */ static get b_s3() { ->b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 158, 5), Decl(commentsClassMembers.ts, 163, 5)) +>b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 157, 5), Decl(commentsClassMembers.ts, 162, 5)) return c1.s2(c1.s1); ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) } /** setter property */ static set b_s3(value: number) { ->b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 158, 5), Decl(commentsClassMembers.ts, 163, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 167, 20)) +>b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 157, 5), Decl(commentsClassMembers.ts, 162, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 166, 20)) /** setter */ c1.b_s1 = c1.b_s2(value); ->c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) +>c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) ->c1.b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 154, 24)) +>b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) +>c1.b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 153, 24)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 154, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 167, 20)) +>b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 153, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 166, 20)) } } var i1 = new c1(); ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) var i1_p = i1.p1; ->i1_p : Symbol(i1_p, Decl(commentsClassMembers.ts, 173, 3)) ->i1.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>i1_p : Symbol(i1_p, Decl(commentsClassMembers.ts, 172, 3)) +>i1.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) var i1_f = i1.p2; ->i1_f : Symbol(i1_f, Decl(commentsClassMembers.ts, 174, 3)) ->i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>i1_f : Symbol(i1_f, Decl(commentsClassMembers.ts, 173, 3)) +>i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) var i1_r = i1.p2(20); ->i1_r : Symbol(i1_r, Decl(commentsClassMembers.ts, 175, 3)) ->i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>i1_r : Symbol(i1_r, Decl(commentsClassMembers.ts, 174, 3)) +>i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) var i1_prop = i1.p3; ->i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 176, 3)) ->i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) +>i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 175, 3)) +>i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) i1.p3 = i1_prop; ->i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 176, 3)) +>i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 175, 3)) var i1_nc_p = i1.nc_p1; ->i1_nc_p : Symbol(i1_nc_p, Decl(commentsClassMembers.ts, 178, 3)) ->i1.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>i1_nc_p : Symbol(i1_nc_p, Decl(commentsClassMembers.ts, 177, 3)) +>i1.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) var i1_ncf = i1.nc_p2; ->i1_ncf : Symbol(i1_ncf, Decl(commentsClassMembers.ts, 179, 3)) ->i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>i1_ncf : Symbol(i1_ncf, Decl(commentsClassMembers.ts, 178, 3)) +>i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) var i1_ncr = i1.nc_p2(20); ->i1_ncr : Symbol(i1_ncr, Decl(commentsClassMembers.ts, 180, 3)) ->i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>i1_ncr : Symbol(i1_ncr, Decl(commentsClassMembers.ts, 179, 3)) +>i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) var i1_ncprop = i1.nc_p3; ->i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 181, 3)) ->i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) +>i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 180, 3)) +>i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) i1.nc_p3 = i1_ncprop; ->i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 181, 3)) +>i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 180, 3)) var i1_s_p = c1.s1; ->i1_s_p : Symbol(i1_s_p, Decl(commentsClassMembers.ts, 183, 3)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>i1_s_p : Symbol(i1_s_p, Decl(commentsClassMembers.ts, 182, 3)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) var i1_s_f = c1.s2; ->i1_s_f : Symbol(i1_s_f, Decl(commentsClassMembers.ts, 184, 3)) ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>i1_s_f : Symbol(i1_s_f, Decl(commentsClassMembers.ts, 183, 3)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) var i1_s_r = c1.s2(20); ->i1_s_r : Symbol(i1_s_r, Decl(commentsClassMembers.ts, 185, 3)) ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>i1_s_r : Symbol(i1_s_r, Decl(commentsClassMembers.ts, 184, 3)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) var i1_s_prop = c1.s3; ->i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 186, 3)) ->c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 185, 3)) +>c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) c1.s3 = i1_s_prop; ->c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) ->i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 186, 3)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) +>i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 185, 3)) var i1_s_nc_p = c1.nc_s1; ->i1_s_nc_p : Symbol(i1_s_nc_p, Decl(commentsClassMembers.ts, 188, 3)) ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>i1_s_nc_p : Symbol(i1_s_nc_p, Decl(commentsClassMembers.ts, 187, 3)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) var i1_s_ncf = c1.nc_s2; ->i1_s_ncf : Symbol(i1_s_ncf, Decl(commentsClassMembers.ts, 189, 3)) ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>i1_s_ncf : Symbol(i1_s_ncf, Decl(commentsClassMembers.ts, 188, 3)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) var i1_s_ncr = c1.nc_s2(20); ->i1_s_ncr : Symbol(i1_s_ncr, Decl(commentsClassMembers.ts, 190, 3)) ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>i1_s_ncr : Symbol(i1_s_ncr, Decl(commentsClassMembers.ts, 189, 3)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) var i1_s_ncprop = c1.nc_s3; ->i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 191, 3)) ->c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 190, 3)) +>c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) c1.nc_s3 = i1_s_ncprop; ->c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) ->i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 191, 3)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) +>i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 190, 3)) var i1_c = c1; ->i1_c : Symbol(i1_c, Decl(commentsClassMembers.ts, 193, 3)) +>i1_c : Symbol(i1_c, Decl(commentsClassMembers.ts, 192, 3)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) class cProperties { ->cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) +>cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) private val: number; ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) /** getter only property*/ public get p1() { ->p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 195, 24)) +>p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 194, 24)) return this.val; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) } // trailing comment of only getter public get nc_p1() { ->nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 199, 5)) +>nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 198, 5)) return this.val; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) } /**setter only property*/ public set p2(value: number) { ->p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 202, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 204, 18)) +>p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 201, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 203, 18)) this.val = value; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 204, 18)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 203, 18)) } public set nc_p2(value: number) { ->nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 206, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 207, 21)) +>nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 205, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 206, 21)) this.val = value; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 207, 21)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 206, 21)) } /* trailing comment of setter only*/ public x = 10; /*trailing comment for property*/ ->x : Symbol(cProperties.x, Decl(commentsClassMembers.ts, 209, 5)) +>x : Symbol(cProperties.x, Decl(commentsClassMembers.ts, 208, 5)) private y = 10; // trailing comment of // style ->y : Symbol(cProperties.y, Decl(commentsClassMembers.ts, 211, 18)) +>y : Symbol(cProperties.y, Decl(commentsClassMembers.ts, 210, 18)) } var cProperties_i = new cProperties(); ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) cProperties_i.p2 = cProperties_i.p1; ->cProperties_i.p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 202, 5)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 202, 5)) ->cProperties_i.p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 195, 24)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 195, 24)) +>cProperties_i.p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 201, 5)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 201, 5)) +>cProperties_i.p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 194, 24)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 194, 24)) cProperties_i.nc_p2 = cProperties_i.nc_p1; ->cProperties_i.nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 206, 5)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 206, 5)) ->cProperties_i.nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 199, 5)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 199, 5)) +>cProperties_i.nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 205, 5)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 205, 5)) +>cProperties_i.nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 198, 5)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 198, 5)) diff --git a/tests/baselines/reference/commentsClassMembers.types b/tests/baselines/reference/commentsClassMembers.types index 3824b8acac0..cd1bfbdd6f0 100644 --- a/tests/baselines/reference/commentsClassMembers.types +++ b/tests/baselines/reference/commentsClassMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsClassMembers.ts === - /** This is comment for c1*/ class c1 { >c1 : c1 diff --git a/tests/baselines/reference/commentsCommentParsing.js b/tests/baselines/reference/commentsCommentParsing.js index 24b2a459bf7..db9b5b6632a 100644 --- a/tests/baselines/reference/commentsCommentParsing.js +++ b/tests/baselines/reference/commentsCommentParsing.js @@ -1,5 +1,4 @@ //// [commentsCommentParsing.ts] - /// This is simple /// comments function simple() { } diff --git a/tests/baselines/reference/commentsCommentParsing.symbols b/tests/baselines/reference/commentsCommentParsing.symbols index abd98074b52..58dac01ae4e 100644 --- a/tests/baselines/reference/commentsCommentParsing.symbols +++ b/tests/baselines/reference/commentsCommentParsing.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsCommentParsing.ts === - /// This is simple /// comments function simple() { >simple : Symbol(simple, Decl(commentsCommentParsing.ts, 0, 0)) @@ -12,27 +11,27 @@ simple(); /// This is example of multiline /// comments /// Another multiLine function multiLine() { ->multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 5, 9)) +>multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 4, 9)) } multiLine(); ->multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 5, 9)) +>multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 4, 9)) /** this is eg of single line jsdoc style comment */ function jsDocSingleLine() { ->jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 12, 12)) +>jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 11, 12)) } jsDocSingleLine(); ->jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 12, 12)) +>jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 11, 12)) /** this is multiple line jsdoc stule comment *New line1 *New Line2*/ function jsDocMultiLine() { ->jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 17, 18)) +>jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 16, 18)) } jsDocMultiLine(); ->jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 17, 18)) +>jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 16, 18)) /** this is multiple line jsdoc stule comment *New line1 @@ -40,54 +39,54 @@ jsDocMultiLine(); /** Shoul mege this line as well * and this too*/ /** Another this one too*/ function jsDocMultiLineMerge() { ->jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 25, 17)) +>jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 24, 17)) } jsDocMultiLineMerge(); ->jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 25, 17)) +>jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 24, 17)) /// Triple slash comment /** jsdoc comment */ function jsDocMixedComments1() { ->jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 34, 22)) +>jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 33, 22)) } jsDocMixedComments1(); ->jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 34, 22)) +>jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 33, 22)) /// Triple slash comment /** jsdoc comment */ /*** another jsDocComment*/ function jsDocMixedComments2() { ->jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 41, 22)) +>jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 40, 22)) } jsDocMixedComments2(); ->jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 41, 22)) +>jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 40, 22)) /** jsdoc comment */ /*** another jsDocComment*/ /// Triple slash comment function jsDocMixedComments3() { ->jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 47, 22)) +>jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 46, 22)) } jsDocMixedComments3(); ->jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 47, 22)) +>jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 46, 22)) /** jsdoc comment */ /*** another jsDocComment*/ /// Triple slash comment /// Triple slash comment 2 function jsDocMixedComments4() { ->jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 53, 22)) +>jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 52, 22)) } jsDocMixedComments4(); ->jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 53, 22)) +>jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 52, 22)) /// Triple slash comment 1 /** jsdoc comment */ /*** another jsDocComment*/ /// Triple slash comment /// Triple slash comment 2 function jsDocMixedComments5() { ->jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 60, 22)) +>jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 59, 22)) } jsDocMixedComments5(); ->jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 60, 22)) +>jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 59, 22)) /*** another jsDocComment*/ /// Triple slash comment 1 @@ -95,46 +94,46 @@ jsDocMixedComments5(); /// Triple slash comment 2 /** jsdoc comment */ function jsDocMixedComments6() { ->jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 68, 22)) +>jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 67, 22)) } jsDocMixedComments6(); ->jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 68, 22)) +>jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 67, 22)) // This shoulnot be help comment function noHelpComment1() { ->noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 77, 22)) +>noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 76, 22)) } noHelpComment1(); ->noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 77, 22)) +>noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 76, 22)) /* This shoulnot be help comment */ function noHelpComment2() { ->noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 82, 17)) +>noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 81, 17)) } noHelpComment2(); ->noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 82, 17)) +>noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 81, 17)) function noHelpComment3() { ->noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 87, 17)) +>noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 86, 17)) } noHelpComment3(); ->noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 87, 17)) +>noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 86, 17)) /** Adds two integers and returns the result * @param {number} a first number * @param b second number */ function sum(a: number, b: number) { ->sum : Symbol(sum, Decl(commentsCommentParsing.ts, 91, 17)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 96, 13)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 96, 23)) +>sum : Symbol(sum, Decl(commentsCommentParsing.ts, 90, 17)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 95, 13)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 95, 23)) return a + b; ->a : Symbol(a, Decl(commentsCommentParsing.ts, 96, 13)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 96, 23)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 95, 13)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 95, 23)) } sum(10, 20); ->sum : Symbol(sum, Decl(commentsCommentParsing.ts, 91, 17)) +>sum : Symbol(sum, Decl(commentsCommentParsing.ts, 90, 17)) /** This is multiplication function*/ /** @param */ @@ -144,32 +143,32 @@ sum(10, 20); @param d @anotherTag*/ /** @param e LastParam @anotherTag*/ function multiply(a: number, b: number, c?: number, d?, e?) { ->multiply : Symbol(multiply, Decl(commentsCommentParsing.ts, 99, 12)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 107, 18)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 107, 28)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 107, 39)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 107, 51)) ->e : Symbol(e, Decl(commentsCommentParsing.ts, 107, 55)) +>multiply : Symbol(multiply, Decl(commentsCommentParsing.ts, 98, 12)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 106, 18)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 106, 28)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 106, 39)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 106, 51)) +>e : Symbol(e, Decl(commentsCommentParsing.ts, 106, 55)) } /** fn f1 with number * @param { string} b about b */ function f1(a: number); ->f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 108, 1), Decl(commentsCommentParsing.ts, 112, 23), Decl(commentsCommentParsing.ts, 113, 23)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 112, 12)) +>f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 107, 1), Decl(commentsCommentParsing.ts, 111, 23), Decl(commentsCommentParsing.ts, 112, 23)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 111, 12)) function f1(b: string); ->f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 108, 1), Decl(commentsCommentParsing.ts, 112, 23), Decl(commentsCommentParsing.ts, 113, 23)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 113, 12)) +>f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 107, 1), Decl(commentsCommentParsing.ts, 111, 23), Decl(commentsCommentParsing.ts, 112, 23)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 112, 12)) /**@param opt optional parameter*/ function f1(aOrb, opt?) { ->f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 108, 1), Decl(commentsCommentParsing.ts, 112, 23), Decl(commentsCommentParsing.ts, 113, 23)) ->aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 115, 12)) ->opt : Symbol(opt, Decl(commentsCommentParsing.ts, 115, 17)) +>f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 107, 1), Decl(commentsCommentParsing.ts, 111, 23), Decl(commentsCommentParsing.ts, 112, 23)) +>aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 114, 12)) +>opt : Symbol(opt, Decl(commentsCommentParsing.ts, 114, 17)) return aOrb; ->aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 115, 12)) +>aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 114, 12)) } /** This is subtract function @param { a @@ -180,13 +179,13 @@ function f1(aOrb, opt?) { @param { { { () => string; } } f this is optional param f */ function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string) { ->subtract : Symbol(subtract, Decl(commentsCommentParsing.ts, 117, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 126, 18)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 126, 28)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 126, 39)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 126, 57)) ->e : Symbol(e, Decl(commentsCommentParsing.ts, 126, 75)) ->f : Symbol(f, Decl(commentsCommentParsing.ts, 126, 93)) +>subtract : Symbol(subtract, Decl(commentsCommentParsing.ts, 116, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 125, 18)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 125, 28)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 125, 39)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 125, 57)) +>e : Symbol(e, Decl(commentsCommentParsing.ts, 125, 75)) +>f : Symbol(f, Decl(commentsCommentParsing.ts, 125, 93)) } /** this is square function @paramTag { number } a this is input number of paramTag @@ -194,12 +193,12 @@ function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: @returnType { number } it is return type */ function square(a: number) { ->square : Symbol(square, Decl(commentsCommentParsing.ts, 127, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 133, 16)) +>square : Symbol(square, Decl(commentsCommentParsing.ts, 126, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 132, 16)) return a * a; ->a : Symbol(a, Decl(commentsCommentParsing.ts, 133, 16)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 133, 16)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 132, 16)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 132, 16)) } /** this is divide function @param { number} a this is a @@ -207,29 +206,29 @@ function square(a: number) { @param { number} b this is b */ function divide(a: number, b: number) { ->divide : Symbol(divide, Decl(commentsCommentParsing.ts, 135, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 141, 16)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 141, 26)) +>divide : Symbol(divide, Decl(commentsCommentParsing.ts, 134, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 140, 16)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 140, 26)) } /** this is jsdoc style function with param tag as well as inline parameter help *@param a it is first parameter *@param c it is third parameter */ function jsDocParamTest(/** this is inline comment for a */a: number, /** this is inline comment for b*/ b: number, c: number, d: number) { ->jsDocParamTest : Symbol(jsDocParamTest, Decl(commentsCommentParsing.ts, 142, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 147, 24)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 147, 69)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 147, 115)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 147, 126)) +>jsDocParamTest : Symbol(jsDocParamTest, Decl(commentsCommentParsing.ts, 141, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 146, 24)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 146, 69)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 146, 115)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 146, 126)) return a + b + c + d; ->a : Symbol(a, Decl(commentsCommentParsing.ts, 147, 24)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 147, 69)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 147, 115)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 147, 126)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 146, 24)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 146, 69)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 146, 115)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 146, 126)) } /**/ class NoQuickInfoClass { ->NoQuickInfoClass : Symbol(NoQuickInfoClass, Decl(commentsCommentParsing.ts, 149, 1)) +>NoQuickInfoClass : Symbol(NoQuickInfoClass, Decl(commentsCommentParsing.ts, 148, 1)) } diff --git a/tests/baselines/reference/commentsCommentParsing.types b/tests/baselines/reference/commentsCommentParsing.types index b41822679d8..2d8e9c8658e 100644 --- a/tests/baselines/reference/commentsCommentParsing.types +++ b/tests/baselines/reference/commentsCommentParsing.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsCommentParsing.ts === - /// This is simple /// comments function simple() { >simple : () => void diff --git a/tests/baselines/reference/commentsDottedModuleName.js b/tests/baselines/reference/commentsDottedModuleName.js index 1c1df104039..89c959ccdab 100644 --- a/tests/baselines/reference/commentsDottedModuleName.js +++ b/tests/baselines/reference/commentsDottedModuleName.js @@ -1,5 +1,4 @@ //// [commentsDottedModuleName.ts] - /** this is multi declare module*/ export module outerModule.InnerModule { /// class b comment diff --git a/tests/baselines/reference/commentsDottedModuleName.symbols b/tests/baselines/reference/commentsDottedModuleName.symbols index 99083b11e3c..b26300edd62 100644 --- a/tests/baselines/reference/commentsDottedModuleName.symbols +++ b/tests/baselines/reference/commentsDottedModuleName.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/commentsDottedModuleName.ts === - /** this is multi declare module*/ export module outerModule.InnerModule { >outerModule : Symbol(outerModule, Decl(commentsDottedModuleName.ts, 0, 0)) ->InnerModule : Symbol(InnerModule, Decl(commentsDottedModuleName.ts, 2, 26)) +>InnerModule : Symbol(InnerModule, Decl(commentsDottedModuleName.ts, 1, 26)) /// class b comment export class b { ->b : Symbol(b, Decl(commentsDottedModuleName.ts, 2, 39)) +>b : Symbol(b, Decl(commentsDottedModuleName.ts, 1, 39)) } } diff --git a/tests/baselines/reference/commentsDottedModuleName.types b/tests/baselines/reference/commentsDottedModuleName.types index 53195bfccfa..377ee40b473 100644 --- a/tests/baselines/reference/commentsDottedModuleName.types +++ b/tests/baselines/reference/commentsDottedModuleName.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsDottedModuleName.ts === - /** this is multi declare module*/ export module outerModule.InnerModule { >outerModule : typeof outerModule diff --git a/tests/baselines/reference/commentsEnums.js b/tests/baselines/reference/commentsEnums.js index 7be17f085b0..c8cd4e38206 100644 --- a/tests/baselines/reference/commentsEnums.js +++ b/tests/baselines/reference/commentsEnums.js @@ -1,5 +1,4 @@ //// [commentsEnums.ts] - /** Enum of colors*/ enum Colors { /** Fancy name for 'blue'*/ diff --git a/tests/baselines/reference/commentsEnums.symbols b/tests/baselines/reference/commentsEnums.symbols index 0f5910f4ee7..912d5a61fc4 100644 --- a/tests/baselines/reference/commentsEnums.symbols +++ b/tests/baselines/reference/commentsEnums.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/commentsEnums.ts === - /** Enum of colors*/ enum Colors { >Colors : Symbol(Colors, Decl(commentsEnums.ts, 0, 0)) /** Fancy name for 'blue'*/ Cornflower /* blue */, ->Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 2, 13)) +>Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 1, 13)) /** Fancy name for 'pink'*/ FancyPink ->FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 4, 26)) +>FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 3, 26)) } // trailing comment var x = Colors.Cornflower; ->x : Symbol(x, Decl(commentsEnums.ts, 8, 3)) ->Colors.Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 2, 13)) +>x : Symbol(x, Decl(commentsEnums.ts, 7, 3)) +>Colors.Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 1, 13)) >Colors : Symbol(Colors, Decl(commentsEnums.ts, 0, 0)) ->Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 2, 13)) +>Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 1, 13)) x = Colors.FancyPink; ->x : Symbol(x, Decl(commentsEnums.ts, 8, 3)) ->Colors.FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 4, 26)) +>x : Symbol(x, Decl(commentsEnums.ts, 7, 3)) +>Colors.FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 3, 26)) >Colors : Symbol(Colors, Decl(commentsEnums.ts, 0, 0)) ->FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 4, 26)) +>FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 3, 26)) diff --git a/tests/baselines/reference/commentsEnums.types b/tests/baselines/reference/commentsEnums.types index 71d062f790a..747f9179440 100644 --- a/tests/baselines/reference/commentsEnums.types +++ b/tests/baselines/reference/commentsEnums.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsEnums.ts === - /** Enum of colors*/ enum Colors { >Colors : Colors diff --git a/tests/baselines/reference/commentsExternalModules.js b/tests/baselines/reference/commentsExternalModules.js index 39002f90d91..7556e8855fb 100644 --- a/tests/baselines/reference/commentsExternalModules.js +++ b/tests/baselines/reference/commentsExternalModules.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsExternalModules.ts] //// //// [commentsExternalModules_0.ts] - /** Module comment*/ export module m1 { /** b's comment*/ diff --git a/tests/baselines/reference/commentsExternalModules.symbols b/tests/baselines/reference/commentsExternalModules.symbols index 6f7852245dd..ab361af481c 100644 --- a/tests/baselines/reference/commentsExternalModules.symbols +++ b/tests/baselines/reference/commentsExternalModules.symbols @@ -4,140 +4,139 @@ import extMod = require("commentsExternalModules_0"); // trailing comment1 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) extMod.m1.fooExport(); ->extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) var newVar = new extMod.m1.m2.c(); >newVar : Symbol(newVar, Decl(commentsExternalModules_1.ts, 3, 3)) ->extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) ->extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) +>extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) +>extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) ->c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) +>m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) +>c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) extMod.m4.fooExport(); ->extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) +>extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) var newVar2 = new extMod.m4.m2.c(); >newVar2 : Symbol(newVar2, Decl(commentsExternalModules_1.ts, 5, 3)) ->extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) ->extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) +>extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) +>extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) === tests/cases/compiler/commentsExternalModules_0.ts === - /** Module comment*/ export module m1 { >m1 : Symbol(m1, Decl(commentsExternalModules_0.ts, 0, 0)) /** b's comment*/ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 3, 14)) /** foo's comment*/ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 3, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 3, 14)) } /** m2 comments*/ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 8, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 7, 5)) /** class comment;*/ export class c { ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 10, 22)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 9, 22)) }; /** i*/ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules_0.ts, 15, 18)) ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 10, 22)) +>i : Symbol(i, Decl(commentsExternalModules_0.ts, 14, 18)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 9, 22)) } /** exported function*/ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 3, 25)) } } m1.fooExport(); ->m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) var myvar = new m1.m2.c(); ->myvar : Symbol(myvar, Decl(commentsExternalModules_0.ts, 23, 3)) ->m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) ->m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) +>myvar : Symbol(myvar, Decl(commentsExternalModules_0.ts, 22, 3)) +>m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) +>m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) ->c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) +>m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) +>c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) /** Module comment */ export module m4 { ->m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 23, 26)) +>m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 22, 26)) /** b's comment */ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 27, 14)) /** foo's comment */ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 27, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 27, 14)) } /** m2 comments */ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 33, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 32, 5)) /** class comment; */ export class c { ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 36, 22)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 35, 22)) }; /** i */ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules_0.ts, 41, 18)) ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 36, 22)) +>i : Symbol(i, Decl(commentsExternalModules_0.ts, 40, 18)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 35, 22)) } /** exported function */ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 27, 25)) } } m4.fooExport(); ->m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) +>m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) var myvar2 = new m4.m2.c(); ->myvar2 : Symbol(myvar2, Decl(commentsExternalModules_0.ts, 49, 3)) ->m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) ->m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) +>myvar2 : Symbol(myvar2, Decl(commentsExternalModules_0.ts, 48, 3)) +>m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) +>m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) diff --git a/tests/baselines/reference/commentsExternalModules.types b/tests/baselines/reference/commentsExternalModules.types index 56b6b338f4d..4515aaad611 100644 --- a/tests/baselines/reference/commentsExternalModules.types +++ b/tests/baselines/reference/commentsExternalModules.types @@ -42,7 +42,6 @@ var newVar2 = new extMod.m4.m2.c(); >c : typeof extMod.m4.m2.c === tests/cases/compiler/commentsExternalModules_0.ts === - /** Module comment*/ export module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/commentsExternalModules2.js b/tests/baselines/reference/commentsExternalModules2.js index d06c588425f..af1e78b692c 100644 --- a/tests/baselines/reference/commentsExternalModules2.js +++ b/tests/baselines/reference/commentsExternalModules2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsExternalModules2.ts] //// //// [commentsExternalModules2_0.ts] - /** Module comment*/ export module m1 { /** b's comment*/ diff --git a/tests/baselines/reference/commentsExternalModules2.symbols b/tests/baselines/reference/commentsExternalModules2.symbols index cfd01db377d..34d6dfbd6e2 100644 --- a/tests/baselines/reference/commentsExternalModules2.symbols +++ b/tests/baselines/reference/commentsExternalModules2.symbols @@ -4,140 +4,139 @@ import extMod = require("commentsExternalModules2_0"); // trailing comment 1 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) extMod.m1.fooExport(); ->extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) export var newVar = new extMod.m1.m2.c(); >newVar : Symbol(newVar, Decl(commentsExternalModules_1.ts, 3, 10)) ->extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) extMod.m4.fooExport(); ->extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) export var newVar2 = new extMod.m4.m2.c(); >newVar2 : Symbol(newVar2, Decl(commentsExternalModules_1.ts, 5, 10)) ->extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) /** b's comment*/ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) /** foo's comment*/ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) } /** m2 comments*/ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 7, 5)) /** class comment;*/ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) }; /** i*/ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 15, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 14, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) } /** exported function*/ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) } } m1.fooExport(); ->m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) var myvar = new m1.m2.c(); ->myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 23, 3)) ->m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 22, 3)) +>m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) /** Module comment */ export module m4 { ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) /** b's comment */ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) /** foo's comment */ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) } /** m2 comments */ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 33, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 32, 5)) /** class comment; */ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) }; /** i */ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 41, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 40, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) } /** exported function */ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) } } m4.fooExport(); ->m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) var myvar2 = new m4.m2.c(); ->myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 49, 3)) ->m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 48, 3)) +>m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) diff --git a/tests/baselines/reference/commentsExternalModules2.types b/tests/baselines/reference/commentsExternalModules2.types index 556b5d11d35..9103d6abceb 100644 --- a/tests/baselines/reference/commentsExternalModules2.types +++ b/tests/baselines/reference/commentsExternalModules2.types @@ -42,7 +42,6 @@ export var newVar2 = new extMod.m4.m2.c(); >c : typeof extMod.m4.m2.c === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/commentsExternalModules3.js b/tests/baselines/reference/commentsExternalModules3.js index 81e90a159d5..e830f9de7a3 100644 --- a/tests/baselines/reference/commentsExternalModules3.js +++ b/tests/baselines/reference/commentsExternalModules3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsExternalModules3.ts] //// //// [commentsExternalModules2_0.ts] - /** Module comment*/ export module m1 { /** b's comment*/ diff --git a/tests/baselines/reference/commentsExternalModules3.symbols b/tests/baselines/reference/commentsExternalModules3.symbols index 4cab3b0d28a..4e74d76906d 100644 --- a/tests/baselines/reference/commentsExternalModules3.symbols +++ b/tests/baselines/reference/commentsExternalModules3.symbols @@ -4,140 +4,139 @@ import extMod = require("./commentsExternalModules2_0"); // trailing comment 1 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) extMod.m1.fooExport(); ->extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) export var newVar = new extMod.m1.m2.c(); >newVar : Symbol(newVar, Decl(commentsExternalModules_1.ts, 3, 10)) ->extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) extMod.m4.fooExport(); ->extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) export var newVar2 = new extMod.m4.m2.c(); >newVar2 : Symbol(newVar2, Decl(commentsExternalModules_1.ts, 5, 10)) ->extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) /** b's comment*/ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) /** foo's comment*/ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) } /** m2 comments*/ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 7, 5)) /** class comment;*/ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) }; /** i*/ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 15, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 14, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) } /** exported function*/ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) } } m1.fooExport(); ->m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) var myvar = new m1.m2.c(); ->myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 23, 3)) ->m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 22, 3)) +>m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) /** Module comment */ export module m4 { ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) /** b's comment */ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) /** foo's comment */ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) } /** m2 comments */ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 33, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 32, 5)) /** class comment; */ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) }; /** i */ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 41, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 40, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) } /** exported function */ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) } } m4.fooExport(); ->m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) var myvar2 = new m4.m2.c(); ->myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 49, 3)) ->m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 48, 3)) +>m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) diff --git a/tests/baselines/reference/commentsExternalModules3.types b/tests/baselines/reference/commentsExternalModules3.types index 2898784b7ea..203e9923676 100644 --- a/tests/baselines/reference/commentsExternalModules3.types +++ b/tests/baselines/reference/commentsExternalModules3.types @@ -42,7 +42,6 @@ export var newVar2 = new extMod.m4.m2.c(); >c : typeof extMod.m4.m2.c === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/commentsFormatting.js b/tests/baselines/reference/commentsFormatting.js index cfee157eada..a754fe9bb85 100644 --- a/tests/baselines/reference/commentsFormatting.js +++ b/tests/baselines/reference/commentsFormatting.js @@ -1,5 +1,4 @@ //// [commentsFormatting.ts] - module m { /** this is first line - aligned to class declaration * this is 4 spaces left aligned diff --git a/tests/baselines/reference/commentsFormatting.symbols b/tests/baselines/reference/commentsFormatting.symbols index a858d48ce67..51cedb6251a 100644 --- a/tests/baselines/reference/commentsFormatting.symbols +++ b/tests/baselines/reference/commentsFormatting.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFormatting.ts === - module m { >m : Symbol(m, Decl(commentsFormatting.ts, 0, 0)) @@ -18,7 +17,7 @@ module m { * this is 7 spaces right aligned * this is 8 spaces right aligned */ export class c { ->c : Symbol(c, Decl(commentsFormatting.ts, 1, 10)) +>c : Symbol(c, Decl(commentsFormatting.ts, 0, 10)) } /** this is first line - 4 spaces right aligned to class but in js file should be aligned to class declaration @@ -40,7 +39,7 @@ module m { * this is 7 spaces right aligned * this is 8 spaces right aligned */ export class c2 { ->c2 : Symbol(c2, Decl(commentsFormatting.ts, 17, 5)) +>c2 : Symbol(c2, Decl(commentsFormatting.ts, 16, 5)) } /** this is comment with new lines in between @@ -70,7 +69,7 @@ this is 4 spaces left aligned but above line is empty above 3 lines are empty*/ export class c3 { ->c3 : Symbol(c3, Decl(commentsFormatting.ts, 38, 5)) +>c3 : Symbol(c3, Decl(commentsFormatting.ts, 37, 5)) } /** this is first line - aligned to class declaration @@ -88,6 +87,6 @@ this is 4 spaces left aligned but above line is empty * this is 11 spaces + tab * this is 12 spaces + tab */ export class c4 { ->c4 : Symbol(c4, Decl(commentsFormatting.ts, 67, 5)) +>c4 : Symbol(c4, Decl(commentsFormatting.ts, 66, 5)) } } diff --git a/tests/baselines/reference/commentsFormatting.types b/tests/baselines/reference/commentsFormatting.types index 2de53654f9e..475de87b8a6 100644 --- a/tests/baselines/reference/commentsFormatting.types +++ b/tests/baselines/reference/commentsFormatting.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFormatting.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/commentsFunction.js b/tests/baselines/reference/commentsFunction.js index d9e9ccd15ea..ad31aa47b91 100644 --- a/tests/baselines/reference/commentsFunction.js +++ b/tests/baselines/reference/commentsFunction.js @@ -1,5 +1,4 @@ //// [commentsFunction.ts] - /** This comment should appear for foo*/ function foo() { } /* trailing comment of function */ diff --git a/tests/baselines/reference/commentsFunction.symbols b/tests/baselines/reference/commentsFunction.symbols index dfc68eb6743..c4860ec0506 100644 --- a/tests/baselines/reference/commentsFunction.symbols +++ b/tests/baselines/reference/commentsFunction.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFunction.ts === - /** This comment should appear for foo*/ function foo() { >foo : Symbol(foo, Decl(commentsFunction.ts, 0, 0)) @@ -10,97 +9,97 @@ foo(); /** This is comment for function signature*/ function fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 4, 6)) ->a : Symbol(a, Decl(commentsFunction.ts, 6, 27)) +>fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 3, 6)) +>a : Symbol(a, Decl(commentsFunction.ts, 5, 27)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(commentsFunction.ts, 6, 66)) +>b : Symbol(b, Decl(commentsFunction.ts, 5, 66)) var d = a; ->d : Symbol(d, Decl(commentsFunction.ts, 9, 7)) ->a : Symbol(a, Decl(commentsFunction.ts, 6, 27)) +>d : Symbol(d, Decl(commentsFunction.ts, 8, 7)) +>a : Symbol(a, Decl(commentsFunction.ts, 5, 27)) } // trailing comment of function fooWithParameters("a", 10); ->fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 4, 6)) +>fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 3, 6)) /** fooFunc * comment */ var fooFunc = function FooFunctionValue(/** fooFunctionValue param */ b: string) { ->fooFunc : Symbol(fooFunc, Decl(commentsFunction.ts, 15, 3)) ->FooFunctionValue : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 15, 13)) ->b : Symbol(b, Decl(commentsFunction.ts, 15, 40)) +>fooFunc : Symbol(fooFunc, Decl(commentsFunction.ts, 14, 3)) +>FooFunctionValue : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 14, 13)) +>b : Symbol(b, Decl(commentsFunction.ts, 14, 40)) return b; ->b : Symbol(b, Decl(commentsFunction.ts, 15, 40)) +>b : Symbol(b, Decl(commentsFunction.ts, 14, 40)) } /// lamdaFoo var comment var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*/b: number) => a + b; ->lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3)) ->a : Symbol(a, Decl(commentsFunction.ts, 20, 46)) ->b : Symbol(b, Decl(commentsFunction.ts, 20, 68)) ->a : Symbol(a, Decl(commentsFunction.ts, 20, 46)) ->b : Symbol(b, Decl(commentsFunction.ts, 20, 68)) +>lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 19, 3)) +>a : Symbol(a, Decl(commentsFunction.ts, 19, 46)) +>b : Symbol(b, Decl(commentsFunction.ts, 19, 68)) +>a : Symbol(a, Decl(commentsFunction.ts, 19, 46)) +>b : Symbol(b, Decl(commentsFunction.ts, 19, 68)) var lambddaNoVarComment = /** this is lambda multiplication*/ (/**param a*/a: number, /**param b*/b: number) => a * b; ->lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 21, 3)) ->a : Symbol(a, Decl(commentsFunction.ts, 21, 63)) ->b : Symbol(b, Decl(commentsFunction.ts, 21, 85)) ->a : Symbol(a, Decl(commentsFunction.ts, 21, 63)) ->b : Symbol(b, Decl(commentsFunction.ts, 21, 85)) +>lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 20, 3)) +>a : Symbol(a, Decl(commentsFunction.ts, 20, 63)) +>b : Symbol(b, Decl(commentsFunction.ts, 20, 85)) +>a : Symbol(a, Decl(commentsFunction.ts, 20, 63)) +>b : Symbol(b, Decl(commentsFunction.ts, 20, 85)) lambdaFoo(10, 20); ->lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3)) +>lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 19, 3)) lambddaNoVarComment(10, 20); ->lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 21, 3)) +>lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 20, 3)) function blah(a: string /* multiline trailing comment ->blah : Symbol(blah, Decl(commentsFunction.ts, 23, 28)) ->a : Symbol(a, Decl(commentsFunction.ts, 25, 14)) +>blah : Symbol(blah, Decl(commentsFunction.ts, 22, 28)) +>a : Symbol(a, Decl(commentsFunction.ts, 24, 14)) multiline */) { } function blah2(a: string /* single line multiple trailing comments */ /* second */) { ->blah2 : Symbol(blah2, Decl(commentsFunction.ts, 27, 1)) ->a : Symbol(a, Decl(commentsFunction.ts, 29, 15)) +>blah2 : Symbol(blah2, Decl(commentsFunction.ts, 26, 1)) +>a : Symbol(a, Decl(commentsFunction.ts, 28, 15)) } function blah3(a: string // trailing commen single line ->blah3 : Symbol(blah3, Decl(commentsFunction.ts, 30, 1)) ->a : Symbol(a, Decl(commentsFunction.ts, 32, 15)) +>blah3 : Symbol(blah3, Decl(commentsFunction.ts, 29, 1)) +>a : Symbol(a, Decl(commentsFunction.ts, 31, 15)) ) { } lambdaFoo = (a, b) => a * b; // This is trailing comment ->lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3)) ->a : Symbol(a, Decl(commentsFunction.ts, 36, 13)) ->b : Symbol(b, Decl(commentsFunction.ts, 36, 15)) ->a : Symbol(a, Decl(commentsFunction.ts, 36, 13)) ->b : Symbol(b, Decl(commentsFunction.ts, 36, 15)) +>lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 19, 3)) +>a : Symbol(a, Decl(commentsFunction.ts, 35, 13)) +>b : Symbol(b, Decl(commentsFunction.ts, 35, 15)) +>a : Symbol(a, Decl(commentsFunction.ts, 35, 13)) +>b : Symbol(b, Decl(commentsFunction.ts, 35, 15)) /*leading comment*/() => 0; // Needs to be wrapped in parens to be a valid expression (not declaration) /*leading comment*/(() => 0); //trailing comment function blah4(/*1*/a: string/*2*/,/*3*/b: string/*4*/) { ->blah4 : Symbol(blah4, Decl(commentsFunction.ts, 39, 29)) ->a : Symbol(a, Decl(commentsFunction.ts, 41, 15)) ->b : Symbol(b, Decl(commentsFunction.ts, 41, 35)) +>blah4 : Symbol(blah4, Decl(commentsFunction.ts, 38, 29)) +>a : Symbol(a, Decl(commentsFunction.ts, 40, 15)) +>b : Symbol(b, Decl(commentsFunction.ts, 40, 35)) } function foo1() { ->foo1 : Symbol(foo1, Decl(commentsFunction.ts, 42, 1)) +>foo1 : Symbol(foo1, Decl(commentsFunction.ts, 41, 1)) // should emit this } function foo2() { ->foo2 : Symbol(foo2, Decl(commentsFunction.ts, 47, 1)) +>foo2 : Symbol(foo2, Decl(commentsFunction.ts, 46, 1)) /// This is some detached comment diff --git a/tests/baselines/reference/commentsFunction.types b/tests/baselines/reference/commentsFunction.types index 75a6cb6eaaf..bf25fb58575 100644 --- a/tests/baselines/reference/commentsFunction.types +++ b/tests/baselines/reference/commentsFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFunction.ts === - /** This comment should appear for foo*/ function foo() { >foo : () => void diff --git a/tests/baselines/reference/commentsInheritance.js b/tests/baselines/reference/commentsInheritance.js index 53fcab2cf3f..e33a4244c03 100644 --- a/tests/baselines/reference/commentsInheritance.js +++ b/tests/baselines/reference/commentsInheritance.js @@ -1,5 +1,4 @@ //// [commentsInheritance.ts] - /** i1 is interface with properties*/ interface i1 { /** i1_p1*/ diff --git a/tests/baselines/reference/commentsInheritance.symbols b/tests/baselines/reference/commentsInheritance.symbols index 288bfdb4280..d5880ad4b26 100644 --- a/tests/baselines/reference/commentsInheritance.symbols +++ b/tests/baselines/reference/commentsInheritance.symbols @@ -1,311 +1,310 @@ === tests/cases/compiler/commentsInheritance.ts === - /** i1 is interface with properties*/ interface i1 { >i1 : Symbol(i1, Decl(commentsInheritance.ts, 0, 0)) /** i1_p1*/ i1_p1: number; ->i1_p1 : Symbol(i1.i1_p1, Decl(commentsInheritance.ts, 2, 14)) +>i1_p1 : Symbol(i1.i1_p1, Decl(commentsInheritance.ts, 1, 14)) /** i1_f1*/ i1_f1(): void; ->i1_f1 : Symbol(i1.i1_f1, Decl(commentsInheritance.ts, 4, 18)) +>i1_f1 : Symbol(i1.i1_f1, Decl(commentsInheritance.ts, 3, 18)) /** i1_l1*/ i1_l1: () => void; ->i1_l1 : Symbol(i1.i1_l1, Decl(commentsInheritance.ts, 6, 18)) +>i1_l1 : Symbol(i1.i1_l1, Decl(commentsInheritance.ts, 5, 18)) // il_nc_p1 i1_nc_p1: number; ->i1_nc_p1 : Symbol(i1.i1_nc_p1, Decl(commentsInheritance.ts, 8, 22)) +>i1_nc_p1 : Symbol(i1.i1_nc_p1, Decl(commentsInheritance.ts, 7, 22)) i1_nc_f1(): void; ->i1_nc_f1 : Symbol(i1.i1_nc_f1, Decl(commentsInheritance.ts, 10, 21)) +>i1_nc_f1 : Symbol(i1.i1_nc_f1, Decl(commentsInheritance.ts, 9, 21)) i1_nc_l1: () => void; ->i1_nc_l1 : Symbol(i1.i1_nc_l1, Decl(commentsInheritance.ts, 11, 21)) +>i1_nc_l1 : Symbol(i1.i1_nc_l1, Decl(commentsInheritance.ts, 10, 21)) p1: number; ->p1 : Symbol(i1.p1, Decl(commentsInheritance.ts, 12, 25)) +>p1 : Symbol(i1.p1, Decl(commentsInheritance.ts, 11, 25)) f1(): void; ->f1 : Symbol(i1.f1, Decl(commentsInheritance.ts, 13, 15)) +>f1 : Symbol(i1.f1, Decl(commentsInheritance.ts, 12, 15)) l1: () => void; ->l1 : Symbol(i1.l1, Decl(commentsInheritance.ts, 14, 15)) +>l1 : Symbol(i1.l1, Decl(commentsInheritance.ts, 13, 15)) nc_p1: number; ->nc_p1 : Symbol(i1.nc_p1, Decl(commentsInheritance.ts, 15, 19)) +>nc_p1 : Symbol(i1.nc_p1, Decl(commentsInheritance.ts, 14, 19)) nc_f1(): void; ->nc_f1 : Symbol(i1.nc_f1, Decl(commentsInheritance.ts, 16, 18)) +>nc_f1 : Symbol(i1.nc_f1, Decl(commentsInheritance.ts, 15, 18)) nc_l1: () => void; ->nc_l1 : Symbol(i1.nc_l1, Decl(commentsInheritance.ts, 17, 18)) +>nc_l1 : Symbol(i1.nc_l1, Decl(commentsInheritance.ts, 16, 18)) } class c1 implements i1 { ->c1 : Symbol(c1, Decl(commentsInheritance.ts, 19, 1)) +>c1 : Symbol(c1, Decl(commentsInheritance.ts, 18, 1)) >i1 : Symbol(i1, Decl(commentsInheritance.ts, 0, 0)) public i1_p1: number; ->i1_p1 : Symbol(c1.i1_p1, Decl(commentsInheritance.ts, 20, 24)) +>i1_p1 : Symbol(c1.i1_p1, Decl(commentsInheritance.ts, 19, 24)) // i1_f1 public i1_f1() { ->i1_f1 : Symbol(c1.i1_f1, Decl(commentsInheritance.ts, 21, 25)) +>i1_f1 : Symbol(c1.i1_f1, Decl(commentsInheritance.ts, 20, 25)) } public i1_l1: () => void; ->i1_l1 : Symbol(c1.i1_l1, Decl(commentsInheritance.ts, 24, 5)) +>i1_l1 : Symbol(c1.i1_l1, Decl(commentsInheritance.ts, 23, 5)) public i1_nc_p1: number; ->i1_nc_p1 : Symbol(c1.i1_nc_p1, Decl(commentsInheritance.ts, 25, 29)) +>i1_nc_p1 : Symbol(c1.i1_nc_p1, Decl(commentsInheritance.ts, 24, 29)) public i1_nc_f1() { ->i1_nc_f1 : Symbol(c1.i1_nc_f1, Decl(commentsInheritance.ts, 26, 28)) +>i1_nc_f1 : Symbol(c1.i1_nc_f1, Decl(commentsInheritance.ts, 25, 28)) } public i1_nc_l1: () => void; ->i1_nc_l1 : Symbol(c1.i1_nc_l1, Decl(commentsInheritance.ts, 28, 5)) +>i1_nc_l1 : Symbol(c1.i1_nc_l1, Decl(commentsInheritance.ts, 27, 5)) /** c1_p1*/ public p1: number; ->p1 : Symbol(c1.p1, Decl(commentsInheritance.ts, 29, 32)) +>p1 : Symbol(c1.p1, Decl(commentsInheritance.ts, 28, 32)) /** c1_f1*/ public f1() { ->f1 : Symbol(c1.f1, Decl(commentsInheritance.ts, 31, 22)) +>f1 : Symbol(c1.f1, Decl(commentsInheritance.ts, 30, 22)) } /** c1_l1*/ public l1: () => void; ->l1 : Symbol(c1.l1, Decl(commentsInheritance.ts, 34, 5)) +>l1 : Symbol(c1.l1, Decl(commentsInheritance.ts, 33, 5)) /** c1_nc_p1*/ public nc_p1: number; ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsInheritance.ts, 36, 26)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsInheritance.ts, 35, 26)) /** c1_nc_f1*/ public nc_f1() { ->nc_f1 : Symbol(c1.nc_f1, Decl(commentsInheritance.ts, 38, 25)) +>nc_f1 : Symbol(c1.nc_f1, Decl(commentsInheritance.ts, 37, 25)) } /** c1_nc_l1*/ public nc_l1: () => void; ->nc_l1 : Symbol(c1.nc_l1, Decl(commentsInheritance.ts, 41, 5)) +>nc_l1 : Symbol(c1.nc_l1, Decl(commentsInheritance.ts, 40, 5)) } var i1_i: i1; ->i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 45, 3)) +>i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 44, 3)) >i1 : Symbol(i1, Decl(commentsInheritance.ts, 0, 0)) var c1_i = new c1(); ->c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 46, 3)) ->c1 : Symbol(c1, Decl(commentsInheritance.ts, 19, 1)) +>c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 45, 3)) +>c1 : Symbol(c1, Decl(commentsInheritance.ts, 18, 1)) // assign to interface i1_i = c1_i; ->i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 45, 3)) ->c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 46, 3)) +>i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 44, 3)) +>c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 45, 3)) class c2 { ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) /** c2 c2_p1*/ public c2_p1: number; ->c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 49, 10)) +>c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 48, 10)) /** c2 c2_f1*/ public c2_f1() { ->c2_f1 : Symbol(c2.c2_f1, Decl(commentsInheritance.ts, 51, 25)) +>c2_f1 : Symbol(c2.c2_f1, Decl(commentsInheritance.ts, 50, 25)) } /** c2 c2_prop*/ public get c2_prop() { ->c2_prop : Symbol(c2.c2_prop, Decl(commentsInheritance.ts, 54, 5)) +>c2_prop : Symbol(c2.c2_prop, Decl(commentsInheritance.ts, 53, 5)) return 10; } public c2_nc_p1: number; ->c2_nc_p1 : Symbol(c2.c2_nc_p1, Decl(commentsInheritance.ts, 58, 5)) +>c2_nc_p1 : Symbol(c2.c2_nc_p1, Decl(commentsInheritance.ts, 57, 5)) public c2_nc_f1() { ->c2_nc_f1 : Symbol(c2.c2_nc_f1, Decl(commentsInheritance.ts, 59, 28)) +>c2_nc_f1 : Symbol(c2.c2_nc_f1, Decl(commentsInheritance.ts, 58, 28)) } public get c2_nc_prop() { ->c2_nc_prop : Symbol(c2.c2_nc_prop, Decl(commentsInheritance.ts, 61, 5)) +>c2_nc_prop : Symbol(c2.c2_nc_prop, Decl(commentsInheritance.ts, 60, 5)) return 10; } /** c2 p1*/ public p1: number; ->p1 : Symbol(c2.p1, Decl(commentsInheritance.ts, 64, 5)) +>p1 : Symbol(c2.p1, Decl(commentsInheritance.ts, 63, 5)) /** c2 f1*/ public f1() { ->f1 : Symbol(c2.f1, Decl(commentsInheritance.ts, 66, 22)) +>f1 : Symbol(c2.f1, Decl(commentsInheritance.ts, 65, 22)) } /** c2 prop*/ public get prop() { ->prop : Symbol(c2.prop, Decl(commentsInheritance.ts, 69, 5)) +>prop : Symbol(c2.prop, Decl(commentsInheritance.ts, 68, 5)) return 10; } public nc_p1: number; ->nc_p1 : Symbol(c2.nc_p1, Decl(commentsInheritance.ts, 73, 5)) +>nc_p1 : Symbol(c2.nc_p1, Decl(commentsInheritance.ts, 72, 5)) public nc_f1() { ->nc_f1 : Symbol(c2.nc_f1, Decl(commentsInheritance.ts, 74, 25)) +>nc_f1 : Symbol(c2.nc_f1, Decl(commentsInheritance.ts, 73, 25)) } public get nc_prop() { ->nc_prop : Symbol(c2.nc_prop, Decl(commentsInheritance.ts, 76, 5)) +>nc_prop : Symbol(c2.nc_prop, Decl(commentsInheritance.ts, 75, 5)) return 10; } /** c2 constructor*/ constructor(a: number) { ->a : Symbol(a, Decl(commentsInheritance.ts, 81, 16)) +>a : Symbol(a, Decl(commentsInheritance.ts, 80, 16)) this.c2_p1 = a; ->this.c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 49, 10)) ->this : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) ->c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 49, 10)) ->a : Symbol(a, Decl(commentsInheritance.ts, 81, 16)) +>this.c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 48, 10)) +>this : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) +>c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 48, 10)) +>a : Symbol(a, Decl(commentsInheritance.ts, 80, 16)) } } class c3 extends c2 { ->c3 : Symbol(c3, Decl(commentsInheritance.ts, 84, 1)) ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c3 : Symbol(c3, Decl(commentsInheritance.ts, 83, 1)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) constructor() { super(10); ->super : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>super : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) } /** c3 p1*/ public p1: number; ->p1 : Symbol(c3.p1, Decl(commentsInheritance.ts, 88, 5)) +>p1 : Symbol(c3.p1, Decl(commentsInheritance.ts, 87, 5)) /** c3 f1*/ public f1() { ->f1 : Symbol(c3.f1, Decl(commentsInheritance.ts, 90, 22)) +>f1 : Symbol(c3.f1, Decl(commentsInheritance.ts, 89, 22)) } /** c3 prop*/ public get prop() { ->prop : Symbol(c3.prop, Decl(commentsInheritance.ts, 93, 5)) +>prop : Symbol(c3.prop, Decl(commentsInheritance.ts, 92, 5)) return 10; } public nc_p1: number; ->nc_p1 : Symbol(c3.nc_p1, Decl(commentsInheritance.ts, 97, 5)) +>nc_p1 : Symbol(c3.nc_p1, Decl(commentsInheritance.ts, 96, 5)) public nc_f1() { ->nc_f1 : Symbol(c3.nc_f1, Decl(commentsInheritance.ts, 98, 25)) +>nc_f1 : Symbol(c3.nc_f1, Decl(commentsInheritance.ts, 97, 25)) } public get nc_prop() { ->nc_prop : Symbol(c3.nc_prop, Decl(commentsInheritance.ts, 100, 5)) +>nc_prop : Symbol(c3.nc_prop, Decl(commentsInheritance.ts, 99, 5)) return 10; } } var c2_i = new c2(10); ->c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 105, 3)) ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 104, 3)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) var c3_i = new c3(); ->c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 106, 3)) ->c3 : Symbol(c3, Decl(commentsInheritance.ts, 84, 1)) +>c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 105, 3)) +>c3 : Symbol(c3, Decl(commentsInheritance.ts, 83, 1)) // assign c2_i = c3_i; ->c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 105, 3)) ->c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 106, 3)) +>c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 104, 3)) +>c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 105, 3)) class c4 extends c2 { ->c4 : Symbol(c4, Decl(commentsInheritance.ts, 108, 12)) ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c4 : Symbol(c4, Decl(commentsInheritance.ts, 107, 12)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) } var c4_i = new c4(10); ->c4_i : Symbol(c4_i, Decl(commentsInheritance.ts, 111, 3)) ->c4 : Symbol(c4, Decl(commentsInheritance.ts, 108, 12)) +>c4_i : Symbol(c4_i, Decl(commentsInheritance.ts, 110, 3)) +>c4 : Symbol(c4, Decl(commentsInheritance.ts, 107, 12)) interface i2 { ->i2 : Symbol(i2, Decl(commentsInheritance.ts, 111, 22)) +>i2 : Symbol(i2, Decl(commentsInheritance.ts, 110, 22)) /** i2_p1*/ i2_p1: number; ->i2_p1 : Symbol(i2.i2_p1, Decl(commentsInheritance.ts, 112, 14)) +>i2_p1 : Symbol(i2.i2_p1, Decl(commentsInheritance.ts, 111, 14)) /** i2_f1*/ i2_f1(): void; ->i2_f1 : Symbol(i2.i2_f1, Decl(commentsInheritance.ts, 114, 18)) +>i2_f1 : Symbol(i2.i2_f1, Decl(commentsInheritance.ts, 113, 18)) /** i2_l1*/ i2_l1: () => void; ->i2_l1 : Symbol(i2.i2_l1, Decl(commentsInheritance.ts, 116, 18)) +>i2_l1 : Symbol(i2.i2_l1, Decl(commentsInheritance.ts, 115, 18)) // i2_nc_p1 i2_nc_p1: number; ->i2_nc_p1 : Symbol(i2.i2_nc_p1, Decl(commentsInheritance.ts, 118, 22)) +>i2_nc_p1 : Symbol(i2.i2_nc_p1, Decl(commentsInheritance.ts, 117, 22)) i2_nc_f1(): void; ->i2_nc_f1 : Symbol(i2.i2_nc_f1, Decl(commentsInheritance.ts, 120, 21)) +>i2_nc_f1 : Symbol(i2.i2_nc_f1, Decl(commentsInheritance.ts, 119, 21)) i2_nc_l1: () => void; ->i2_nc_l1 : Symbol(i2.i2_nc_l1, Decl(commentsInheritance.ts, 121, 21)) +>i2_nc_l1 : Symbol(i2.i2_nc_l1, Decl(commentsInheritance.ts, 120, 21)) /** i2 p1*/ p1: number; ->p1 : Symbol(i2.p1, Decl(commentsInheritance.ts, 122, 25)) +>p1 : Symbol(i2.p1, Decl(commentsInheritance.ts, 121, 25)) /** i2 f1*/ f1(): void; ->f1 : Symbol(i2.f1, Decl(commentsInheritance.ts, 124, 15)) +>f1 : Symbol(i2.f1, Decl(commentsInheritance.ts, 123, 15)) /** i2 l1*/ l1: () => void; ->l1 : Symbol(i2.l1, Decl(commentsInheritance.ts, 126, 15)) +>l1 : Symbol(i2.l1, Decl(commentsInheritance.ts, 125, 15)) nc_p1: number; ->nc_p1 : Symbol(i2.nc_p1, Decl(commentsInheritance.ts, 128, 19)) +>nc_p1 : Symbol(i2.nc_p1, Decl(commentsInheritance.ts, 127, 19)) nc_f1(): void; ->nc_f1 : Symbol(i2.nc_f1, Decl(commentsInheritance.ts, 129, 18)) +>nc_f1 : Symbol(i2.nc_f1, Decl(commentsInheritance.ts, 128, 18)) nc_l1: () => void; ->nc_l1 : Symbol(i2.nc_l1, Decl(commentsInheritance.ts, 130, 18)) +>nc_l1 : Symbol(i2.nc_l1, Decl(commentsInheritance.ts, 129, 18)) } interface i3 extends i2 { ->i3 : Symbol(i3, Decl(commentsInheritance.ts, 132, 1)) ->i2 : Symbol(i2, Decl(commentsInheritance.ts, 111, 22)) +>i3 : Symbol(i3, Decl(commentsInheritance.ts, 131, 1)) +>i2 : Symbol(i2, Decl(commentsInheritance.ts, 110, 22)) /** i3 p1 */ p1: number; ->p1 : Symbol(i3.p1, Decl(commentsInheritance.ts, 133, 25)) +>p1 : Symbol(i3.p1, Decl(commentsInheritance.ts, 132, 25)) /** * i3 f1 */ f1(): void; ->f1 : Symbol(i3.f1, Decl(commentsInheritance.ts, 135, 15)) +>f1 : Symbol(i3.f1, Decl(commentsInheritance.ts, 134, 15)) /** i3 l1*/ l1: () => void; ->l1 : Symbol(i3.l1, Decl(commentsInheritance.ts, 139, 15)) +>l1 : Symbol(i3.l1, Decl(commentsInheritance.ts, 138, 15)) nc_p1: number; ->nc_p1 : Symbol(i3.nc_p1, Decl(commentsInheritance.ts, 141, 19)) +>nc_p1 : Symbol(i3.nc_p1, Decl(commentsInheritance.ts, 140, 19)) nc_f1(): void; ->nc_f1 : Symbol(i3.nc_f1, Decl(commentsInheritance.ts, 142, 18)) +>nc_f1 : Symbol(i3.nc_f1, Decl(commentsInheritance.ts, 141, 18)) nc_l1: () => void; ->nc_l1 : Symbol(i3.nc_l1, Decl(commentsInheritance.ts, 143, 18)) +>nc_l1 : Symbol(i3.nc_l1, Decl(commentsInheritance.ts, 142, 18)) } var i2_i: i2; ->i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 146, 3)) ->i2 : Symbol(i2, Decl(commentsInheritance.ts, 111, 22)) +>i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 145, 3)) +>i2 : Symbol(i2, Decl(commentsInheritance.ts, 110, 22)) var i3_i: i3; ->i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 147, 3)) ->i3 : Symbol(i3, Decl(commentsInheritance.ts, 132, 1)) +>i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 146, 3)) +>i3 : Symbol(i3, Decl(commentsInheritance.ts, 131, 1)) // assign to interface i2_i = i3_i; ->i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 146, 3)) ->i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 147, 3)) +>i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 145, 3)) +>i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 146, 3)) diff --git a/tests/baselines/reference/commentsInheritance.types b/tests/baselines/reference/commentsInheritance.types index 804da3fd760..a6fbc449fc1 100644 --- a/tests/baselines/reference/commentsInheritance.types +++ b/tests/baselines/reference/commentsInheritance.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsInheritance.ts === - /** i1 is interface with properties*/ interface i1 { >i1 : i1 diff --git a/tests/baselines/reference/commentsMultiModuleMultiFile.js b/tests/baselines/reference/commentsMultiModuleMultiFile.js index 25dd8a90780..6aaace19afc 100644 --- a/tests/baselines/reference/commentsMultiModuleMultiFile.js +++ b/tests/baselines/reference/commentsMultiModuleMultiFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsMultiModuleMultiFile.ts] //// //// [commentsMultiModuleMultiFile_0.ts] - /** this is multi declare module*/ export module multiM { /// class b comment diff --git a/tests/baselines/reference/commentsMultiModuleMultiFile.symbols b/tests/baselines/reference/commentsMultiModuleMultiFile.symbols index 1ca90840af4..87f0fe50212 100644 --- a/tests/baselines/reference/commentsMultiModuleMultiFile.symbols +++ b/tests/baselines/reference/commentsMultiModuleMultiFile.symbols @@ -22,38 +22,37 @@ new multiM.d(); >d : Symbol(multiM.d, Decl(commentsMultiModuleMultiFile_1.ts, 2, 22)) === tests/cases/compiler/commentsMultiModuleMultiFile_0.ts === - /** this is multi declare module*/ export module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) /// class b comment export class b { ->b : Symbol(b, Decl(commentsMultiModuleMultiFile_0.ts, 2, 22)) +>b : Symbol(b, Decl(commentsMultiModuleMultiFile_0.ts, 1, 22)) } } /** thi is multi module 2*/ export module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) /** class c comment*/ export class c { ->c : Symbol(c, Decl(commentsMultiModuleMultiFile_0.ts, 8, 22)) +>c : Symbol(c, Decl(commentsMultiModuleMultiFile_0.ts, 7, 22)) } // class e comment export class e { ->e : Symbol(e, Decl(commentsMultiModuleMultiFile_0.ts, 11, 5)) +>e : Symbol(e, Decl(commentsMultiModuleMultiFile_0.ts, 10, 5)) } } new multiM.b(); ->multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 2, 22)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) ->b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 2, 22)) +>multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 1, 22)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) +>b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 1, 22)) new multiM.c(); ->multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 8, 22)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) ->c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 8, 22)) +>multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 7, 22)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) +>c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 7, 22)) diff --git a/tests/baselines/reference/commentsMultiModuleMultiFile.types b/tests/baselines/reference/commentsMultiModuleMultiFile.types index c0f3fb1b875..fef48659b2a 100644 --- a/tests/baselines/reference/commentsMultiModuleMultiFile.types +++ b/tests/baselines/reference/commentsMultiModuleMultiFile.types @@ -23,7 +23,6 @@ new multiM.d(); >d : typeof multiM.d === tests/cases/compiler/commentsMultiModuleMultiFile_0.ts === - /** this is multi declare module*/ export module multiM { >multiM : typeof multiM diff --git a/tests/baselines/reference/commentsMultiModuleSingleFile.js b/tests/baselines/reference/commentsMultiModuleSingleFile.js index 0e00a3eaff6..34e693b34db 100644 --- a/tests/baselines/reference/commentsMultiModuleSingleFile.js +++ b/tests/baselines/reference/commentsMultiModuleSingleFile.js @@ -1,5 +1,4 @@ //// [commentsMultiModuleSingleFile.ts] - /** this is multi declare module*/ module multiM { /** class b*/ diff --git a/tests/baselines/reference/commentsMultiModuleSingleFile.symbols b/tests/baselines/reference/commentsMultiModuleSingleFile.symbols index 678d9aaf830..a6af9521474 100644 --- a/tests/baselines/reference/commentsMultiModuleSingleFile.symbols +++ b/tests/baselines/reference/commentsMultiModuleSingleFile.symbols @@ -1,41 +1,40 @@ === tests/cases/compiler/commentsMultiModuleSingleFile.ts === - /** this is multi declare module*/ module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) /** class b*/ export class b { ->b : Symbol(b, Decl(commentsMultiModuleSingleFile.ts, 2, 15)) +>b : Symbol(b, Decl(commentsMultiModuleSingleFile.ts, 1, 15)) } // class d export class d { ->d : Symbol(d, Decl(commentsMultiModuleSingleFile.ts, 5, 5)) +>d : Symbol(d, Decl(commentsMultiModuleSingleFile.ts, 4, 5)) } } /// this is multi module 2 module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) /** class c comment*/ export class c { ->c : Symbol(c, Decl(commentsMultiModuleSingleFile.ts, 13, 15)) +>c : Symbol(c, Decl(commentsMultiModuleSingleFile.ts, 12, 15)) } /// class e export class e { ->e : Symbol(e, Decl(commentsMultiModuleSingleFile.ts, 16, 5)) +>e : Symbol(e, Decl(commentsMultiModuleSingleFile.ts, 15, 5)) } } new multiM.b(); ->multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 2, 15)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) ->b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 2, 15)) +>multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 1, 15)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) +>b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 1, 15)) new multiM.c(); ->multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 13, 15)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) ->c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 13, 15)) +>multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 12, 15)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) +>c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 12, 15)) diff --git a/tests/baselines/reference/commentsMultiModuleSingleFile.types b/tests/baselines/reference/commentsMultiModuleSingleFile.types index 29c18639c21..213119c91a5 100644 --- a/tests/baselines/reference/commentsMultiModuleSingleFile.types +++ b/tests/baselines/reference/commentsMultiModuleSingleFile.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsMultiModuleSingleFile.ts === - /** this is multi declare module*/ module multiM { >multiM : typeof multiM diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.js b/tests/baselines/reference/commentsOnObjectLiteral3.js index 49f2a6ffbf9..e6c08f2a318 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral3.js +++ b/tests/baselines/reference/commentsOnObjectLiteral3.js @@ -1,5 +1,4 @@ //// [commentsOnObjectLiteral3.ts] - var v = { //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.symbols b/tests/baselines/reference/commentsOnObjectLiteral3.symbols index 3d58fe2d6d7..5805180d74d 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral3.symbols +++ b/tests/baselines/reference/commentsOnObjectLiteral3.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/commentsOnObjectLiteral3.ts === - var v = { ->v : Symbol(v, Decl(commentsOnObjectLiteral3.ts, 1, 3)) +>v : Symbol(v, Decl(commentsOnObjectLiteral3.ts, 0, 3)) //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, ->prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 1, 9)) +>prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 0, 9)) //property func: function () { ->func : Symbol(func, Decl(commentsOnObjectLiteral3.ts, 3, 64)) +>func : Symbol(func, Decl(commentsOnObjectLiteral3.ts, 2, 64)) }, //PropertyName + CallSignature func1() { }, ->func1 : Symbol(func1, Decl(commentsOnObjectLiteral3.ts, 6, 3)) +>func1 : Symbol(func1, Decl(commentsOnObjectLiteral3.ts, 5, 3)) //getter get a() { ->a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 8, 13), Decl(commentsOnObjectLiteral3.ts, 12, 18)) +>a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 7, 13), Decl(commentsOnObjectLiteral3.ts, 11, 18)) return this.prop; } /*trailing 1*/, //setter set a(value) { ->a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 8, 13), Decl(commentsOnObjectLiteral3.ts, 12, 18)) ->value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 14, 7)) +>a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 7, 13), Decl(commentsOnObjectLiteral3.ts, 11, 18)) +>value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 13, 7)) this.prop = value; ->value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 14, 7)) +>value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 13, 7)) } // trailing 2 }; diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.types b/tests/baselines/reference/commentsOnObjectLiteral3.types index 4053e7e3f89..3c264d4502b 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral3.types +++ b/tests/baselines/reference/commentsOnObjectLiteral3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnObjectLiteral3.ts === - var v = { >v : { prop: number; func: () => void; func1(): void; a: any; } >{ //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, //property func: function () { }, //PropertyName + CallSignature func1() { }, //getter get a() { return this.prop; } /*trailing 1*/, //setter set a(value) { this.prop = value; } // trailing 2} : { prop: number; func: () => void; func1(): void; a: any; } diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.js b/tests/baselines/reference/commentsOnObjectLiteral4.js index 23e238b8307..749201c2f75 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral4.js +++ b/tests/baselines/reference/commentsOnObjectLiteral4.js @@ -1,5 +1,4 @@ //// [commentsOnObjectLiteral4.ts] - var v = { /** * @type {number} diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.symbols b/tests/baselines/reference/commentsOnObjectLiteral4.symbols index 568d6332126..eb0a8a3e3f0 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral4.symbols +++ b/tests/baselines/reference/commentsOnObjectLiteral4.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/commentsOnObjectLiteral4.ts === - var v = { ->v : Symbol(v, Decl(commentsOnObjectLiteral4.ts, 1, 3)) +>v : Symbol(v, Decl(commentsOnObjectLiteral4.ts, 0, 3)) /** * @type {number} */ get bar(): number { ->bar : Symbol(bar, Decl(commentsOnObjectLiteral4.ts, 1, 9)) +>bar : Symbol(bar, Decl(commentsOnObjectLiteral4.ts, 0, 9)) return 12; } diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.types b/tests/baselines/reference/commentsOnObjectLiteral4.types index 097d43cdd6d..aa0293edc6c 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral4.types +++ b/tests/baselines/reference/commentsOnObjectLiteral4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnObjectLiteral4.ts === - var v = { >v : { readonly bar: number; } >{ /** * @type {number} */ get bar(): number { return 12; }} : { readonly bar: number; } diff --git a/tests/baselines/reference/commentsOnRequireStatement.js b/tests/baselines/reference/commentsOnRequireStatement.js index eee05c80493..2a39206ecf3 100644 --- a/tests/baselines/reference/commentsOnRequireStatement.js +++ b/tests/baselines/reference/commentsOnRequireStatement.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsOnRequireStatement.ts] //// //// [0.ts] - export var subject = 10; //// [1.ts] diff --git a/tests/baselines/reference/commentsOnRequireStatement.symbols b/tests/baselines/reference/commentsOnRequireStatement.symbols index 2e491b33234..ec9c4684620 100644 --- a/tests/baselines/reference/commentsOnRequireStatement.symbols +++ b/tests/baselines/reference/commentsOnRequireStatement.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/0.ts === - export var subject = 10; ->subject : Symbol(subject, Decl(0.ts, 1, 10)) +>subject : Symbol(subject, Decl(0.ts, 0, 10)) === tests/cases/compiler/1.ts === export var subject1 = 10; diff --git a/tests/baselines/reference/commentsOnRequireStatement.types b/tests/baselines/reference/commentsOnRequireStatement.types index cd146c731f7..bee717b3dda 100644 --- a/tests/baselines/reference/commentsOnRequireStatement.types +++ b/tests/baselines/reference/commentsOnRequireStatement.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - export var subject = 10; >subject : number >10 : 10 diff --git a/tests/baselines/reference/commentsOnStaticMembers.js b/tests/baselines/reference/commentsOnStaticMembers.js index 851f9025be3..94df4089880 100644 --- a/tests/baselines/reference/commentsOnStaticMembers.js +++ b/tests/baselines/reference/commentsOnStaticMembers.js @@ -1,5 +1,4 @@ //// [commentsOnStaticMembers.ts] - class test { /** * p1 comment appears in output diff --git a/tests/baselines/reference/commentsOnStaticMembers.symbols b/tests/baselines/reference/commentsOnStaticMembers.symbols index 4e59ba7bca9..7986db58cda 100644 --- a/tests/baselines/reference/commentsOnStaticMembers.symbols +++ b/tests/baselines/reference/commentsOnStaticMembers.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnStaticMembers.ts === - class test { >test : Symbol(test, Decl(commentsOnStaticMembers.ts, 0, 0)) @@ -7,23 +6,23 @@ class test { * p1 comment appears in output */ public static p1: string = ""; ->p1 : Symbol(test.p1, Decl(commentsOnStaticMembers.ts, 1, 12)) +>p1 : Symbol(test.p1, Decl(commentsOnStaticMembers.ts, 0, 12)) /** * p2 comment does not appear in output */ public static p2: string; ->p2 : Symbol(test.p2, Decl(commentsOnStaticMembers.ts, 5, 34)) +>p2 : Symbol(test.p2, Decl(commentsOnStaticMembers.ts, 4, 34)) /** * p3 comment appears in output */ private static p3: string = ""; ->p3 : Symbol(test.p3, Decl(commentsOnStaticMembers.ts, 9, 29)) +>p3 : Symbol(test.p3, Decl(commentsOnStaticMembers.ts, 8, 29)) /** * p4 comment does not appear in output */ private static p4: string; ->p4 : Symbol(test.p4, Decl(commentsOnStaticMembers.ts, 14, 35)) +>p4 : Symbol(test.p4, Decl(commentsOnStaticMembers.ts, 13, 35)) } diff --git a/tests/baselines/reference/commentsOnStaticMembers.types b/tests/baselines/reference/commentsOnStaticMembers.types index b4fae1094b6..c8b3771f3cd 100644 --- a/tests/baselines/reference/commentsOnStaticMembers.types +++ b/tests/baselines/reference/commentsOnStaticMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnStaticMembers.ts === - class test { >test : test diff --git a/tests/baselines/reference/commentsVarDecl.js b/tests/baselines/reference/commentsVarDecl.js index 5ff2a3c1c6a..001b3b5ed1f 100644 --- a/tests/baselines/reference/commentsVarDecl.js +++ b/tests/baselines/reference/commentsVarDecl.js @@ -1,5 +1,4 @@ //// [commentsVarDecl.ts] - /** Variable comments*/ var myVariable = 10; // This trailing Comment1 diff --git a/tests/baselines/reference/commentsVarDecl.symbols b/tests/baselines/reference/commentsVarDecl.symbols index d2ec3d4edcd..54a1462e28f 100644 --- a/tests/baselines/reference/commentsVarDecl.symbols +++ b/tests/baselines/reference/commentsVarDecl.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/commentsVarDecl.ts === - /** Variable comments*/ var myVariable = 10; // This trailing Comment1 ->myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 2, 3)) +>myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 1, 3)) /** This is another variable comment*/ var anotherVariable = 30; ->anotherVariable : Symbol(anotherVariable, Decl(commentsVarDecl.ts, 5, 3)) +>anotherVariable : Symbol(anotherVariable, Decl(commentsVarDecl.ts, 4, 3)) // shouldn't appear var aVar = ""; ->aVar : Symbol(aVar, Decl(commentsVarDecl.ts, 8, 3)) +>aVar : Symbol(aVar, Decl(commentsVarDecl.ts, 7, 3)) /** this is multiline comment * All these variables are of number type */ var anotherAnotherVariable = 70; /* these are multiple trailing comments */ /* multiple trailing comments */ ->anotherAnotherVariable : Symbol(anotherAnotherVariable, Decl(commentsVarDecl.ts, 12, 3)) +>anotherAnotherVariable : Symbol(anotherAnotherVariable, Decl(commentsVarDecl.ts, 11, 3)) /** Triple slash multiline comment*/ /** another line in the comment*/ /** comment line 2*/ var x = 70; /* multiline trailing comment ->x : Symbol(x, Decl(commentsVarDecl.ts, 17, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 16, 3)) this is multiline trailing comment */ /** Triple slash comment on the assignement shouldnt be in .d.ts file*/ x = myVariable; ->x : Symbol(x, Decl(commentsVarDecl.ts, 17, 3)) ->myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 2, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 16, 3)) +>myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 1, 3)) /** triple slash comment1*/ /** jsdocstyle comment - only this comment should be in .d.ts file*/ var n = 30; ->n : Symbol(n, Decl(commentsVarDecl.ts, 24, 3)) +>n : Symbol(n, Decl(commentsVarDecl.ts, 23, 3)) /** var deckaration with comment on type as well*/ var y = /** value comment */ 20; ->y : Symbol(y, Decl(commentsVarDecl.ts, 27, 3)) +>y : Symbol(y, Decl(commentsVarDecl.ts, 26, 3)) /// var deckaration with comment on type as well var yy = ->yy : Symbol(yy, Decl(commentsVarDecl.ts, 30, 3)) +>yy : Symbol(yy, Decl(commentsVarDecl.ts, 29, 3)) /// value comment 20; /** comment2 */ var z = /** lambda comment */ (x: number, y: number) => x + y; ->z : Symbol(z, Decl(commentsVarDecl.ts, 35, 3)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31)) ->y : Symbol(y, Decl(commentsVarDecl.ts, 35, 41)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31)) ->y : Symbol(y, Decl(commentsVarDecl.ts, 35, 41)) +>z : Symbol(z, Decl(commentsVarDecl.ts, 34, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 34, 31)) +>y : Symbol(y, Decl(commentsVarDecl.ts, 34, 41)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 34, 31)) +>y : Symbol(y, Decl(commentsVarDecl.ts, 34, 41)) var z2: /** type comment*/ (x: number) => string; ->z2 : Symbol(z2, Decl(commentsVarDecl.ts, 37, 3)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 37, 28)) +>z2 : Symbol(z2, Decl(commentsVarDecl.ts, 36, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 36, 28)) var x2 = z2; ->x2 : Symbol(x2, Decl(commentsVarDecl.ts, 39, 3)) ->z2 : Symbol(z2, Decl(commentsVarDecl.ts, 37, 3)) +>x2 : Symbol(x2, Decl(commentsVarDecl.ts, 38, 3)) +>z2 : Symbol(z2, Decl(commentsVarDecl.ts, 36, 3)) var n4: (x: number) => string; ->n4 : Symbol(n4, Decl(commentsVarDecl.ts, 41, 3)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 41, 9)) +>n4 : Symbol(n4, Decl(commentsVarDecl.ts, 40, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 40, 9)) n4 = z2; ->n4 : Symbol(n4, Decl(commentsVarDecl.ts, 41, 3)) ->z2 : Symbol(z2, Decl(commentsVarDecl.ts, 37, 3)) +>n4 : Symbol(n4, Decl(commentsVarDecl.ts, 40, 3)) +>z2 : Symbol(z2, Decl(commentsVarDecl.ts, 36, 3)) diff --git a/tests/baselines/reference/commentsVarDecl.types b/tests/baselines/reference/commentsVarDecl.types index 1127f5ed3f4..a81c329f002 100644 --- a/tests/baselines/reference/commentsVarDecl.types +++ b/tests/baselines/reference/commentsVarDecl.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsVarDecl.ts === - /** Variable comments*/ var myVariable = 10; // This trailing Comment1 >myVariable : number diff --git a/tests/baselines/reference/commentsVariableStatement1.js b/tests/baselines/reference/commentsVariableStatement1.js index bc60253e24c..1e9579b0706 100644 --- a/tests/baselines/reference/commentsVariableStatement1.js +++ b/tests/baselines/reference/commentsVariableStatement1.js @@ -1,5 +1,4 @@ //// [commentsVariableStatement1.ts] - /** Comment */ var v = 1; diff --git a/tests/baselines/reference/commentsVariableStatement1.symbols b/tests/baselines/reference/commentsVariableStatement1.symbols index 54f382da793..aebf32a21bb 100644 --- a/tests/baselines/reference/commentsVariableStatement1.symbols +++ b/tests/baselines/reference/commentsVariableStatement1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/commentsVariableStatement1.ts === - /** Comment */ var v = 1; ->v : Symbol(v, Decl(commentsVariableStatement1.ts, 2, 3)) +>v : Symbol(v, Decl(commentsVariableStatement1.ts, 1, 3)) diff --git a/tests/baselines/reference/commentsVariableStatement1.types b/tests/baselines/reference/commentsVariableStatement1.types index 1684f25c570..540edc2b2a3 100644 --- a/tests/baselines/reference/commentsVariableStatement1.types +++ b/tests/baselines/reference/commentsVariableStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsVariableStatement1.ts === - /** Comment */ var v = 1; >v : number diff --git a/tests/baselines/reference/commentsdoNotEmitComments.js b/tests/baselines/reference/commentsdoNotEmitComments.js index b77f51348f0..d4d57a7c35f 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.js +++ b/tests/baselines/reference/commentsdoNotEmitComments.js @@ -1,5 +1,4 @@ //// [commentsdoNotEmitComments.ts] - /** Variable comments*/ var myVariable = 10; diff --git a/tests/baselines/reference/commentsdoNotEmitComments.symbols b/tests/baselines/reference/commentsdoNotEmitComments.symbols index 01555496dce..89324cf1670 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.symbols +++ b/tests/baselines/reference/commentsdoNotEmitComments.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/commentsdoNotEmitComments.ts === - /** Variable comments*/ var myVariable = 10; ->myVariable : Symbol(myVariable, Decl(commentsdoNotEmitComments.ts, 2, 3)) +>myVariable : Symbol(myVariable, Decl(commentsdoNotEmitComments.ts, 1, 3)) /** function comments*/ function foo(/** parameter comment*/p: number) { ->foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 2, 20)) ->p : Symbol(p, Decl(commentsdoNotEmitComments.ts, 5, 13)) +>foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 1, 20)) +>p : Symbol(p, Decl(commentsdoNotEmitComments.ts, 4, 13)) } /** variable with function type comment*/ var fooVar: () => void; ->fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 8, 3)) foo(50); ->foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 2, 20)) +>foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 1, 20)) fooVar(); ->fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 8, 3)) /**class comment*/ class c { ->c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) +>c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) /** constructor comment*/ constructor() { @@ -30,132 +29,132 @@ class c { /** property comment */ public b = 10; ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) /** function comment */ public myFoo() { ->myFoo : Symbol(c.myFoo, Decl(commentsdoNotEmitComments.ts, 20, 18)) +>myFoo : Symbol(c.myFoo, Decl(commentsdoNotEmitComments.ts, 19, 18)) return this.b; ->this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) } /** getter comment*/ public get prop1() { ->prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 25, 5), Decl(commentsdoNotEmitComments.ts, 30, 5)) +>prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 24, 5), Decl(commentsdoNotEmitComments.ts, 29, 5)) return this.b; ->this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) } /** setter comment*/ public set prop1(val: number) { ->prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 25, 5), Decl(commentsdoNotEmitComments.ts, 30, 5)) ->val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 33, 21)) +>prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 24, 5), Decl(commentsdoNotEmitComments.ts, 29, 5)) +>val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 32, 21)) this.b = val; ->this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 33, 21)) +>this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 32, 21)) } /** overload signature1*/ public foo1(a: number): string; ->foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 35, 5), Decl(commentsdoNotEmitComments.ts, 38, 35), Decl(commentsdoNotEmitComments.ts, 40, 35)) ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 38, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 34, 5), Decl(commentsdoNotEmitComments.ts, 37, 35), Decl(commentsdoNotEmitComments.ts, 39, 35)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 37, 16)) /** Overload signature 2*/ public foo1(b: string): string; ->foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 35, 5), Decl(commentsdoNotEmitComments.ts, 38, 35), Decl(commentsdoNotEmitComments.ts, 40, 35)) ->b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 40, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 34, 5), Decl(commentsdoNotEmitComments.ts, 37, 35), Decl(commentsdoNotEmitComments.ts, 39, 35)) +>b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 39, 16)) /** overload implementation signature*/ public foo1(aOrb) { ->foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 35, 5), Decl(commentsdoNotEmitComments.ts, 38, 35), Decl(commentsdoNotEmitComments.ts, 40, 35)) ->aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 42, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 34, 5), Decl(commentsdoNotEmitComments.ts, 37, 35), Decl(commentsdoNotEmitComments.ts, 39, 35)) +>aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 41, 16)) return aOrb.toString(); ->aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 42, 16)) +>aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 41, 16)) } } /**instance comment*/ var i = new c(); ->i : Symbol(i, Decl(commentsdoNotEmitComments.ts, 48, 3)) ->c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) +>i : Symbol(i, Decl(commentsdoNotEmitComments.ts, 47, 3)) +>c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) /** interface comments*/ interface i1 { ->i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 48, 16)) +>i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 47, 16)) /** caller comments*/ (a: number): number; ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 53, 5)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 52, 5)) /** new comments*/ new (b: string); ->b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 56, 9)) +>b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 55, 9)) /**indexer property*/ [a: number]: string; ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 59, 5)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 58, 5)) /** function property;*/ myFoo(/*param prop*/a: number): string; ->myFoo : Symbol(i1.myFoo, Decl(commentsdoNotEmitComments.ts, 59, 24)) ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 62, 10)) +>myFoo : Symbol(i1.myFoo, Decl(commentsdoNotEmitComments.ts, 58, 24)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 61, 10)) /** prop*/ prop: string; ->prop : Symbol(i1.prop, Decl(commentsdoNotEmitComments.ts, 62, 43)) +>prop : Symbol(i1.prop, Decl(commentsdoNotEmitComments.ts, 61, 43)) } /**interface instance comments*/ var i1_i: i1; ->i1_i : Symbol(i1_i, Decl(commentsdoNotEmitComments.ts, 69, 3)) ->i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 48, 16)) +>i1_i : Symbol(i1_i, Decl(commentsdoNotEmitComments.ts, 68, 3)) +>i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 47, 16)) /** this is module comment*/ module m1 { ->m1 : Symbol(m1, Decl(commentsdoNotEmitComments.ts, 69, 13)) +>m1 : Symbol(m1, Decl(commentsdoNotEmitComments.ts, 68, 13)) /** class b */ export class b { ->b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 72, 11)) +>b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 71, 11)) constructor(public x: number) { ->x : Symbol(b.x, Decl(commentsdoNotEmitComments.ts, 75, 20)) +>x : Symbol(b.x, Decl(commentsdoNotEmitComments.ts, 74, 20)) } } /// module m2 export module m2 { ->m2 : Symbol(m2, Decl(commentsdoNotEmitComments.ts, 78, 5)) +>m2 : Symbol(m2, Decl(commentsdoNotEmitComments.ts, 77, 5)) } } /// this is x declare var x; ->x : Symbol(x, Decl(commentsdoNotEmitComments.ts, 86, 11)) +>x : Symbol(x, Decl(commentsdoNotEmitComments.ts, 85, 11)) /** const enum member value comment (generated by TS) */ const enum color { red, green, blue } ->color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 86, 14)) ->red : Symbol(color.red, Decl(commentsdoNotEmitComments.ts, 90, 18)) ->green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 90, 23)) ->blue : Symbol(color.blue, Decl(commentsdoNotEmitComments.ts, 90, 30)) +>color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 85, 14)) +>red : Symbol(color.red, Decl(commentsdoNotEmitComments.ts, 89, 18)) +>green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 89, 23)) +>blue : Symbol(color.blue, Decl(commentsdoNotEmitComments.ts, 89, 30)) var shade: color = color.green; ->shade : Symbol(shade, Decl(commentsdoNotEmitComments.ts, 91, 3)) ->color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 86, 14)) ->color.green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 90, 23)) ->color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 86, 14)) ->green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 90, 23)) +>shade : Symbol(shade, Decl(commentsdoNotEmitComments.ts, 90, 3)) +>color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 85, 14)) +>color.green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 89, 23)) +>color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 85, 14)) +>green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 89, 23)) diff --git a/tests/baselines/reference/commentsdoNotEmitComments.types b/tests/baselines/reference/commentsdoNotEmitComments.types index e30555db69a..1c30eeca50b 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.types +++ b/tests/baselines/reference/commentsdoNotEmitComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsdoNotEmitComments.ts === - /** Variable comments*/ var myVariable = 10; >myVariable : number diff --git a/tests/baselines/reference/commentsemitComments.js b/tests/baselines/reference/commentsemitComments.js index 442f558bcfa..6e0497fcf7f 100644 --- a/tests/baselines/reference/commentsemitComments.js +++ b/tests/baselines/reference/commentsemitComments.js @@ -1,5 +1,4 @@ //// [commentsemitComments.ts] - /** Variable comments*/ var myVariable = 10; diff --git a/tests/baselines/reference/commentsemitComments.symbols b/tests/baselines/reference/commentsemitComments.symbols index eec41dccec6..08ae7df0494 100644 --- a/tests/baselines/reference/commentsemitComments.symbols +++ b/tests/baselines/reference/commentsemitComments.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/commentsemitComments.ts === - /** Variable comments*/ var myVariable = 10; ->myVariable : Symbol(myVariable, Decl(commentsemitComments.ts, 2, 3)) +>myVariable : Symbol(myVariable, Decl(commentsemitComments.ts, 1, 3)) /** function comments*/ function foo(/** parameter comment*/p: number) { ->foo : Symbol(foo, Decl(commentsemitComments.ts, 2, 20)) ->p : Symbol(p, Decl(commentsemitComments.ts, 5, 13)) +>foo : Symbol(foo, Decl(commentsemitComments.ts, 1, 20)) +>p : Symbol(p, Decl(commentsemitComments.ts, 4, 13)) } /** variable with function type comment*/ var fooVar: () => void; ->fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 8, 3)) foo(50); ->foo : Symbol(foo, Decl(commentsemitComments.ts, 2, 20)) +>foo : Symbol(foo, Decl(commentsemitComments.ts, 1, 20)) fooVar(); ->fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 8, 3)) /**class comment*/ class c { ->c : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) +>c : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) /** constructor comment*/ constructor() { @@ -30,117 +29,117 @@ class c { /** property comment */ public b = 10; ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) /** function comment */ public myFoo() { ->myFoo : Symbol(c.myFoo, Decl(commentsemitComments.ts, 20, 18)) +>myFoo : Symbol(c.myFoo, Decl(commentsemitComments.ts, 19, 18)) return this.b; ->this.b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) } /** getter comment*/ public get prop1() { ->prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 25, 5), Decl(commentsemitComments.ts, 30, 5)) +>prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 24, 5), Decl(commentsemitComments.ts, 29, 5)) return this.b; ->this.b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) } /** setter comment*/ public set prop1(val: number) { ->prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 25, 5), Decl(commentsemitComments.ts, 30, 5)) ->val : Symbol(val, Decl(commentsemitComments.ts, 33, 21)) +>prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 24, 5), Decl(commentsemitComments.ts, 29, 5)) +>val : Symbol(val, Decl(commentsemitComments.ts, 32, 21)) this.b = val; ->this.b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->val : Symbol(val, Decl(commentsemitComments.ts, 33, 21)) +>this.b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>val : Symbol(val, Decl(commentsemitComments.ts, 32, 21)) } /** overload signature1*/ public foo1(a: number): string; ->foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 35, 5), Decl(commentsemitComments.ts, 38, 35), Decl(commentsemitComments.ts, 40, 35)) ->a : Symbol(a, Decl(commentsemitComments.ts, 38, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 34, 5), Decl(commentsemitComments.ts, 37, 35), Decl(commentsemitComments.ts, 39, 35)) +>a : Symbol(a, Decl(commentsemitComments.ts, 37, 16)) /** Overload signature 2*/ public foo1(b: string): string; ->foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 35, 5), Decl(commentsemitComments.ts, 38, 35), Decl(commentsemitComments.ts, 40, 35)) ->b : Symbol(b, Decl(commentsemitComments.ts, 40, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 34, 5), Decl(commentsemitComments.ts, 37, 35), Decl(commentsemitComments.ts, 39, 35)) +>b : Symbol(b, Decl(commentsemitComments.ts, 39, 16)) /** overload implementation signature*/ public foo1(aOrb) { ->foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 35, 5), Decl(commentsemitComments.ts, 38, 35), Decl(commentsemitComments.ts, 40, 35)) ->aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 42, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 34, 5), Decl(commentsemitComments.ts, 37, 35), Decl(commentsemitComments.ts, 39, 35)) +>aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 41, 16)) return aOrb.toString(); ->aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 42, 16)) +>aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 41, 16)) } } /**instance comment*/ var i = new c(); ->i : Symbol(i, Decl(commentsemitComments.ts, 48, 3)) ->c : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) +>i : Symbol(i, Decl(commentsemitComments.ts, 47, 3)) +>c : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) /** interface comments*/ interface i1 { ->i1 : Symbol(i1, Decl(commentsemitComments.ts, 48, 16)) +>i1 : Symbol(i1, Decl(commentsemitComments.ts, 47, 16)) /** caller comments*/ (a: number): number; ->a : Symbol(a, Decl(commentsemitComments.ts, 53, 5)) +>a : Symbol(a, Decl(commentsemitComments.ts, 52, 5)) /** new comments*/ new (b: string); ->b : Symbol(b, Decl(commentsemitComments.ts, 56, 9)) +>b : Symbol(b, Decl(commentsemitComments.ts, 55, 9)) /**indexer property*/ [a: number]: string; ->a : Symbol(a, Decl(commentsemitComments.ts, 59, 5)) +>a : Symbol(a, Decl(commentsemitComments.ts, 58, 5)) /** function property;*/ myFoo(/*param prop*/a: number): string; ->myFoo : Symbol(i1.myFoo, Decl(commentsemitComments.ts, 59, 24)) ->a : Symbol(a, Decl(commentsemitComments.ts, 62, 10)) +>myFoo : Symbol(i1.myFoo, Decl(commentsemitComments.ts, 58, 24)) +>a : Symbol(a, Decl(commentsemitComments.ts, 61, 10)) /** prop*/ prop: string; ->prop : Symbol(i1.prop, Decl(commentsemitComments.ts, 62, 43)) +>prop : Symbol(i1.prop, Decl(commentsemitComments.ts, 61, 43)) } /**interface instance comments*/ var i1_i: i1; ->i1_i : Symbol(i1_i, Decl(commentsemitComments.ts, 69, 3)) ->i1 : Symbol(i1, Decl(commentsemitComments.ts, 48, 16)) +>i1_i : Symbol(i1_i, Decl(commentsemitComments.ts, 68, 3)) +>i1 : Symbol(i1, Decl(commentsemitComments.ts, 47, 16)) /** this is module comment*/ module m1 { ->m1 : Symbol(m1, Decl(commentsemitComments.ts, 69, 13)) +>m1 : Symbol(m1, Decl(commentsemitComments.ts, 68, 13)) /** class b */ export class b { ->b : Symbol(b, Decl(commentsemitComments.ts, 72, 11)) +>b : Symbol(b, Decl(commentsemitComments.ts, 71, 11)) constructor(public x: number) { ->x : Symbol(b.x, Decl(commentsemitComments.ts, 75, 20)) +>x : Symbol(b.x, Decl(commentsemitComments.ts, 74, 20)) } } /// module m2 export module m2 { ->m2 : Symbol(m2, Decl(commentsemitComments.ts, 78, 5)) +>m2 : Symbol(m2, Decl(commentsemitComments.ts, 77, 5)) } } /// this is x declare var x; ->x : Symbol(x, Decl(commentsemitComments.ts, 86, 11)) +>x : Symbol(x, Decl(commentsemitComments.ts, 85, 11)) diff --git a/tests/baselines/reference/commentsemitComments.types b/tests/baselines/reference/commentsemitComments.types index 03bf0912092..6c2429091e2 100644 --- a/tests/baselines/reference/commentsemitComments.types +++ b/tests/baselines/reference/commentsemitComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsemitComments.ts === - /** Variable comments*/ var myVariable = 10; >myVariable : number diff --git a/tests/baselines/reference/commonSourceDir5.js b/tests/baselines/reference/commonSourceDir5.js index ef6e97f4d5e..78517e4e515 100644 --- a/tests/baselines/reference/commonSourceDir5.js +++ b/tests/baselines/reference/commonSourceDir5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commonSourceDir5.ts] //// //// [bar.ts] - import {z} from "./foo"; export var x = z + z; diff --git a/tests/baselines/reference/commonSourceDir5.symbols b/tests/baselines/reference/commonSourceDir5.symbols index 67494af40fa..6426ac39de3 100644 --- a/tests/baselines/reference/commonSourceDir5.symbols +++ b/tests/baselines/reference/commonSourceDir5.symbols @@ -1,12 +1,11 @@ === A:/bar.ts === - import {z} from "./foo"; ->z : Symbol(z, Decl(bar.ts, 1, 8)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) export var x = z + z; ->x : Symbol(x, Decl(bar.ts, 2, 10)) ->z : Symbol(z, Decl(bar.ts, 1, 8)) ->z : Symbol(z, Decl(bar.ts, 1, 8)) +>x : Symbol(x, Decl(bar.ts, 1, 10)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) === A:/foo.ts === import {pi} from "B:/baz"; diff --git a/tests/baselines/reference/commonSourceDir5.types b/tests/baselines/reference/commonSourceDir5.types index f1c3e40e983..3e2b99f3259 100644 --- a/tests/baselines/reference/commonSourceDir5.types +++ b/tests/baselines/reference/commonSourceDir5.types @@ -1,5 +1,4 @@ === A:/bar.ts === - import {z} from "./foo"; >z : number diff --git a/tests/baselines/reference/commonjsSafeImport.js b/tests/baselines/reference/commonjsSafeImport.js index e7a251e9cee..5eb560f8bb9 100644 --- a/tests/baselines/reference/commonjsSafeImport.js +++ b/tests/baselines/reference/commonjsSafeImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commonjsSafeImport.ts] //// //// [10_lib.ts] - export function Foo() {} //// [main.ts] diff --git a/tests/baselines/reference/commonjsSafeImport.symbols b/tests/baselines/reference/commonjsSafeImport.symbols index 45e247b46a0..d08497ca3a5 100644 --- a/tests/baselines/reference/commonjsSafeImport.symbols +++ b/tests/baselines/reference/commonjsSafeImport.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/10_lib.ts === - export function Foo() {} >Foo : Symbol(Foo, Decl(10_lib.ts, 0, 0)) diff --git a/tests/baselines/reference/commonjsSafeImport.types b/tests/baselines/reference/commonjsSafeImport.types index 5a4dded5b1f..898b26f62ab 100644 --- a/tests/baselines/reference/commonjsSafeImport.types +++ b/tests/baselines/reference/commonjsSafeImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/10_lib.ts === - export function Foo() {} >Foo : () => void diff --git a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols index 4448defa95e..5aba2118e27 100644 --- a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types index 6f5caf9d48b..66a158067e4 100644 --- a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols index 4448defa95e..5aba2118e27 100644 --- a/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsOutAndNoEmit.types b/tests/baselines/reference/compilerOptionsOutAndNoEmit.types index 6f5caf9d48b..66a158067e4 100644 --- a/tests/baselines/reference/compilerOptionsOutAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsOutAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols index 4448defa95e..5aba2118e27 100644 --- a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types index 6f5caf9d48b..66a158067e4 100644 --- a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols index 4448defa95e..5aba2118e27 100644 --- a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types index 6f5caf9d48b..66a158067e4 100644 --- a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt index 8948467c590..7b9eb40dee0 100644 --- a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt +++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt @@ -1,83 +1,82 @@ -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(9,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(13,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(17,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(11,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(21,5): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(22,5): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(23,5): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(25,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(26,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(27,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(30,1): error TS2539: Cannot assign to 'M' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2539: Cannot assign to 'M' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(32,1): error TS2539: Cannot assign to 'M' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(33,1): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2539: Cannot assign to 'C' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(35,1): error TS2539: Cannot assign to 'C' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(37,1): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2539: Cannot assign to 'E' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(39,1): error TS2539: Cannot assign to 'E' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(40,1): error TS2539: Cannot assign to 'foo' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2539: Cannot assign to 'foo' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(42,1): error TS2539: Cannot assign to 'foo' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2531: Object is possibly 'null'. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(50,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(51,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(56,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(58,9): error TS1128: Declaration or statement expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(59,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(60,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(64,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(62,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(69,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(70,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(71,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(74,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(75,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(76,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(79,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(80,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(81,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(85,21): error TS1128: Declaration or statement expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(86,21): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,21): error TS1128: Declaration or statement expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,11): error TS1005: ';' expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(88,11): error TS1005: ';' expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(89,11): error TS1005: ';' expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(93,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(91,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(95,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(96,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,2): error TS2539: Cannot assign to 'M' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,2): error TS2539: Cannot assign to 'M' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,2): error TS2539: Cannot assign to 'M' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,2): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,2): error TS2539: Cannot assign to 'C' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,2): error TS2539: Cannot assign to 'C' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,2): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,2): error TS2539: Cannot assign to 'E' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,2): error TS2539: Cannot assign to 'E' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,2): error TS2539: Cannot assign to 'foo' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,2): error TS2539: Cannot assign to 'foo' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,2): error TS2539: Cannot assign to 'foo' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2531: Object is possibly 'null'. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(109,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(110,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(123,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. ==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (76 errors) ==== - // expected error for all the LHS of compound assignments (arithmetic and addition) var value: any; diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.js b/tests/baselines/reference/compoundAssignmentLHSIsValue.js index 064f2157c1e..f5a0fc75da5 100644 --- a/tests/baselines/reference/compoundAssignmentLHSIsValue.js +++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.js @@ -1,5 +1,4 @@ //// [compoundAssignmentLHSIsValue.ts] - // expected error for all the LHS of compound assignments (arithmetic and addition) var value: any; diff --git a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js index e0bd16287ee..c75890748fc 100644 --- a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js +++ b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js @@ -1,5 +1,4 @@ //// [computedPropertiesInDestructuring2_ES6.ts] - let foo2 = () => "bar"; let {[foo2()]: bar3} = {}; diff --git a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols index cd7cfda9844..fdf6c0eeb7f 100644 --- a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols +++ b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/computedPropertiesInDestructuring2_ES6.ts === - let foo2 = () => "bar"; ->foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 1, 3)) +>foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 0, 3)) let {[foo2()]: bar3} = {}; ->foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 1, 3)) ->bar3 : Symbol(bar3, Decl(computedPropertiesInDestructuring2_ES6.ts, 2, 5)) +>foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 0, 3)) +>bar3 : Symbol(bar3, Decl(computedPropertiesInDestructuring2_ES6.ts, 1, 5)) diff --git a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types index 979689438d2..e59addd3a26 100644 --- a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types +++ b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/computedPropertiesInDestructuring2_ES6.ts === - let foo2 = () => "bar"; >foo2 : () => string >() => "bar" : () => string diff --git a/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt index cb4034d3bad..02721368a0d 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(4,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(7,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(10,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(14,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(14,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(19,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(3,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(6,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(13,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(13,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(18,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts (8 errors) ==== - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames49_ES5.js b/tests/baselines/reference/computedPropertyNames49_ES5.js index d4eb26a08a5..d5e250fb037 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES5.js +++ b/tests/baselines/reference/computedPropertyNames49_ES5.js @@ -1,5 +1,4 @@ //// [computedPropertyNames49_ES5.ts] - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt index 276f7fb17be..094da3258d6 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(10,9): error TS1049: A 'set' accessor must have exactly one parameter. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(14,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(9,9): error TS1049: A 'set' accessor must have exactly one parameter. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(13,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts (4 errors) ==== - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames49_ES6.js b/tests/baselines/reference/computedPropertyNames49_ES6.js index d1b5fe26e9d..d75df44463f 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES6.js +++ b/tests/baselines/reference/computedPropertyNames49_ES6.js @@ -1,5 +1,4 @@ //// [computedPropertyNames49_ES6.ts] - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt index 63832dbed0c..12d3dde2950 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(4,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(4,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(12,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(16,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(19,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(3,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(3,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(8,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(11,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(15,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(18,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts (8 errors) ==== - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES5.js b/tests/baselines/reference/computedPropertyNames50_ES5.js index 0c6f1798c93..5f1766c993e 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES5.js +++ b/tests/baselines/reference/computedPropertyNames50_ES5.js @@ -1,5 +1,4 @@ //// [computedPropertyNames50_ES5.ts] - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt index db61444a697..e2cd3f215bf 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(4,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(12,9): error TS1049: A 'set' accessor must have exactly one parameter. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(3,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(11,9): error TS1049: A 'set' accessor must have exactly one parameter. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts (4 errors) ==== - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES6.js b/tests/baselines/reference/computedPropertyNames50_ES6.js index 24b0c8af1f5..aa4cc931234 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES6.js +++ b/tests/baselines/reference/computedPropertyNames50_ES6.js @@ -1,5 +1,4 @@ //// [computedPropertyNames50_ES6.ts] - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/concatError.js b/tests/baselines/reference/concatError.js index dee3d8a30e3..67361719702 100644 --- a/tests/baselines/reference/concatError.js +++ b/tests/baselines/reference/concatError.js @@ -1,5 +1,4 @@ //// [concatError.ts] - var n1: number[]; /* interface Array { diff --git a/tests/baselines/reference/concatError.symbols b/tests/baselines/reference/concatError.symbols index d4f04531fc7..2dcc2f3abd8 100644 --- a/tests/baselines/reference/concatError.symbols +++ b/tests/baselines/reference/concatError.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/concatError.ts === - var n1: number[]; ->n1 : Symbol(n1, Decl(concatError.ts, 1, 3)) +>n1 : Symbol(n1, Decl(concatError.ts, 0, 3)) /* interface Array { @@ -10,18 +9,18 @@ interface Array { } */ var fa: number[]; ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) fa = fa.concat([0]); ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) fa = fa.concat(0); ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/concatError.types b/tests/baselines/reference/concatError.types index bb9a85a91b4..f97018cd3b9 100644 --- a/tests/baselines/reference/concatError.types +++ b/tests/baselines/reference/concatError.types @@ -1,5 +1,4 @@ === tests/cases/compiler/concatError.ts === - var n1: number[]; >n1 : number[] diff --git a/tests/baselines/reference/conditionalExpressions2.js b/tests/baselines/reference/conditionalExpressions2.js index 8ac7df12cfa..6749a2c0ac0 100644 --- a/tests/baselines/reference/conditionalExpressions2.js +++ b/tests/baselines/reference/conditionalExpressions2.js @@ -1,5 +1,4 @@ //// [conditionalExpressions2.ts] - var a = false ? 1 : null; var b = false ? undefined : 0; var c = false ? 1 : 0; diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols index e6edd635b40..63c8b417477 100644 --- a/tests/baselines/reference/conditionalExpressions2.symbols +++ b/tests/baselines/reference/conditionalExpressions2.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/conditionalExpressions2.ts === - var a = false ? 1 : null; ->a : Symbol(a, Decl(conditionalExpressions2.ts, 1, 3)) +>a : Symbol(a, Decl(conditionalExpressions2.ts, 0, 3)) var b = false ? undefined : 0; ->b : Symbol(b, Decl(conditionalExpressions2.ts, 2, 3)) +>b : Symbol(b, Decl(conditionalExpressions2.ts, 1, 3)) >undefined : Symbol(undefined) var c = false ? 1 : 0; ->c : Symbol(c, Decl(conditionalExpressions2.ts, 3, 3)) +>c : Symbol(c, Decl(conditionalExpressions2.ts, 2, 3)) var d = false ? false : true; ->d : Symbol(d, Decl(conditionalExpressions2.ts, 4, 3)) +>d : Symbol(d, Decl(conditionalExpressions2.ts, 3, 3)) var e = false ? "foo" : "bar"; ->e : Symbol(e, Decl(conditionalExpressions2.ts, 5, 3)) +>e : Symbol(e, Decl(conditionalExpressions2.ts, 4, 3)) var f = false ? null : undefined; ->f : Symbol(f, Decl(conditionalExpressions2.ts, 6, 3)) +>f : Symbol(f, Decl(conditionalExpressions2.ts, 5, 3)) >undefined : Symbol(undefined) var g = true ? {g:5} : null; ->g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 3)) ->g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 16)) +>g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 3)) +>g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 16)) var h = [{h:5}, null]; ->h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 3)) ->h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 10)) +>h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 3)) +>h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 10)) function i() { if (true) { return { x: 5 }; } else { return null; } } ->i : Symbol(i, Decl(conditionalExpressions2.ts, 8, 22)) ->x : Symbol(x, Decl(conditionalExpressions2.ts, 9, 35)) +>i : Symbol(i, Decl(conditionalExpressions2.ts, 7, 22)) +>x : Symbol(x, Decl(conditionalExpressions2.ts, 8, 35)) diff --git a/tests/baselines/reference/conditionalExpressions2.types b/tests/baselines/reference/conditionalExpressions2.types index c2b2e23e57b..325a281738f 100644 --- a/tests/baselines/reference/conditionalExpressions2.types +++ b/tests/baselines/reference/conditionalExpressions2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/conditionalExpressions2.ts === - var a = false ? 1 : null; >a : number >false ? 1 : null : 1 diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt index 24af601139f..54aa6baf49c 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(7,9): error TS2481: Cannot initialize outer scoped variable 'x' in the same scope as block scoped declaration 'x'. -tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(15,13): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. -tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(22,7): error TS2481: Cannot initialize outer scoped variable 'z' in the same scope as block scoped declaration 'z'. +tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(6,9): error TS2481: Cannot initialize outer scoped variable 'x' in the same scope as block scoped declaration 'x'. +tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(14,13): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. +tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(21,7): error TS2481: Cannot initialize outer scoped variable 'z' in the same scope as block scoped declaration 'z'. ==== tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts (3 errors) ==== - // Error as declaration of var would cause a write to the const value var x = 0; { diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js index 9fcc9f8f568..fff38e729fd 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js @@ -1,5 +1,4 @@ //// [constDeclarationShadowedByVarDeclaration.ts] - // Error as declaration of var would cause a write to the const value var x = 0; { diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js index 67d3e688075..895b4122d66 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js @@ -1,5 +1,4 @@ //// [constDeclarationShadowedByVarDeclaration2.ts] - // No errors, const declaration is not shadowed function outer() { const x = 0; diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols index db53aa8fb92..cd187a59447 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/constDeclarationShadowedByVarDeclaration2.ts === - // No errors, const declaration is not shadowed function outer() { >outer : Symbol(outer, Decl(constDeclarationShadowedByVarDeclaration2.ts, 0, 0)) const x = 0; ->x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 3, 9)) +>x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 2, 9)) function inner() { ->inner : Symbol(inner, Decl(constDeclarationShadowedByVarDeclaration2.ts, 3, 16)) +>inner : Symbol(inner, Decl(constDeclarationShadowedByVarDeclaration2.ts, 2, 16)) var x = "inner"; ->x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 5, 11)) +>x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 4, 11)) } } diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types index 23e81800264..3e3821372cc 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarationShadowedByVarDeclaration2.ts === - // No errors, const declaration is not shadowed function outer() { >outer : () => void diff --git a/tests/baselines/reference/constDeclarations-access.errors.txt b/tests/baselines/reference/constDeclarations-access.errors.txt index 81121b6fe5c..c9c730456e2 100644 --- a/tests/baselines/reference/constDeclarations-access.errors.txt +++ b/tests/baselines/reference/constDeclarations-access.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/file2.ts(1,1): error TS2540: Cannot assign to 'x' because i ==== tests/cases/compiler/file1.ts (0 errors) ==== - const x = 0 ==== tests/cases/compiler/file2.ts (1 errors) ==== diff --git a/tests/baselines/reference/constDeclarations-access.js b/tests/baselines/reference/constDeclarations-access.js index ba913f2d5fc..dd5624bcf4c 100644 --- a/tests/baselines/reference/constDeclarations-access.js +++ b/tests/baselines/reference/constDeclarations-access.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/constDeclarations-access.ts] //// //// [file1.ts] - const x = 0 //// [file2.ts] diff --git a/tests/baselines/reference/constDeclarations-access2.errors.txt b/tests/baselines/reference/constDeclarations-access2.errors.txt index 16335bfa59c..dc8b4d5b90b 100644 --- a/tests/baselines/reference/constDeclarations-access2.errors.txt +++ b/tests/baselines/reference/constDeclarations-access2.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/constDeclarations-access2.ts(4,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(5,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(6,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(7,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. @@ -9,16 +10,14 @@ tests/cases/compiler/constDeclarations-access2.ts(12,1): error TS2540: Cannot as tests/cases/compiler/constDeclarations-access2.ts(13,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(14,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(15,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(16,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access2.ts(17,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(18,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(19,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access2.ts(19,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(20,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(21,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(23,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access2.ts(22,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. ==== tests/cases/compiler/constDeclarations-access2.ts (17 errors) ==== - const x = 0 // Errors diff --git a/tests/baselines/reference/constDeclarations-access2.js b/tests/baselines/reference/constDeclarations-access2.js index ae8dae70646..33bca0691bf 100644 --- a/tests/baselines/reference/constDeclarations-access2.js +++ b/tests/baselines/reference/constDeclarations-access2.js @@ -1,5 +1,4 @@ //// [constDeclarations-access2.ts] - const x = 0 // Errors diff --git a/tests/baselines/reference/constDeclarations-access3.errors.txt b/tests/baselines/reference/constDeclarations-access3.errors.txt index 03ea2d29bba..dd55ef9166d 100644 --- a/tests/baselines/reference/constDeclarations-access3.errors.txt +++ b/tests/baselines/reference/constDeclarations-access3.errors.txt @@ -1,3 +1,5 @@ +tests/cases/compiler/constDeclarations-access3.ts(6,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(7,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(8,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(9,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(10,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. @@ -8,19 +10,15 @@ tests/cases/compiler/constDeclarations-access3.ts(14,3): error TS2540: Cannot as tests/cases/compiler/constDeclarations-access3.ts(15,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(16,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(17,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(18,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(19,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(21,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(22,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(23,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(24,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(26,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(28,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(20,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(21,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(22,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(24,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(26,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. ==== tests/cases/compiler/constDeclarations-access3.ts (18 errors) ==== - - module M { export const x = 0; } diff --git a/tests/baselines/reference/constDeclarations-access3.js b/tests/baselines/reference/constDeclarations-access3.js index 9140da965c3..945c6883213 100644 --- a/tests/baselines/reference/constDeclarations-access3.js +++ b/tests/baselines/reference/constDeclarations-access3.js @@ -1,6 +1,4 @@ //// [constDeclarations-access3.ts] - - module M { export const x = 0; } diff --git a/tests/baselines/reference/constDeclarations-access4.errors.txt b/tests/baselines/reference/constDeclarations-access4.errors.txt index a4111c2d702..5bc4f1fadda 100644 --- a/tests/baselines/reference/constDeclarations-access4.errors.txt +++ b/tests/baselines/reference/constDeclarations-access4.errors.txt @@ -1,3 +1,5 @@ +tests/cases/compiler/constDeclarations-access4.ts(6,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(7,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(8,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(9,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(10,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. @@ -8,19 +10,15 @@ tests/cases/compiler/constDeclarations-access4.ts(14,3): error TS2540: Cannot as tests/cases/compiler/constDeclarations-access4.ts(15,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(16,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(17,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(18,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(19,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(21,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(22,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(23,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(24,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(26,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(28,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(20,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(21,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(22,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(24,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(26,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. ==== tests/cases/compiler/constDeclarations-access4.ts (18 errors) ==== - - declare module M { const x: number; } diff --git a/tests/baselines/reference/constDeclarations-access4.js b/tests/baselines/reference/constDeclarations-access4.js index 608d950526a..851322ceea5 100644 --- a/tests/baselines/reference/constDeclarations-access4.js +++ b/tests/baselines/reference/constDeclarations-access4.js @@ -1,6 +1,4 @@ //// [constDeclarations-access4.ts] - - declare module M { const x: number; } diff --git a/tests/baselines/reference/constDeclarations-access5.errors.txt b/tests/baselines/reference/constDeclarations-access5.errors.txt index 316465e80b8..61d579dccc5 100644 --- a/tests/baselines/reference/constDeclarations-access5.errors.txt +++ b/tests/baselines/reference/constDeclarations-access5.errors.txt @@ -97,7 +97,5 @@ tests/cases/compiler/constDeclarations_access_2.ts(24,3): error TS2540: Cannot a m.x.toString(); ==== tests/cases/compiler/constDeclarations_access_1.ts (0 errors) ==== - - export const x = 0; \ No newline at end of file diff --git a/tests/baselines/reference/constDeclarations-access5.js b/tests/baselines/reference/constDeclarations-access5.js index f02b9611541..cb5d2447718 100644 --- a/tests/baselines/reference/constDeclarations-access5.js +++ b/tests/baselines/reference/constDeclarations-access5.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/constDeclarations-access5.ts] //// //// [constDeclarations_access_1.ts] - - export const x = 0; //// [constDeclarations_access_2.ts] diff --git a/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt b/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt index 2ecc7fc7ed3..979448abf72 100644 --- a/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt +++ b/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/constDeclarations-ambient-errors.ts(3,27): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(4,26): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(5,20): error TS1254: A 'const' initializer in an ambient context must be a string or numeric literal. -tests/cases/compiler/constDeclarations-ambient-errors.ts(5,37): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(5,51): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(9,22): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(2,27): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(3,26): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(4,20): error TS1254: A 'const' initializer in an ambient context must be a string or numeric literal. +tests/cases/compiler/constDeclarations-ambient-errors.ts(4,37): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(4,51): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(8,22): error TS1039: Initializers are not allowed in ambient contexts. ==== tests/cases/compiler/constDeclarations-ambient-errors.ts (6 errors) ==== - // error: no intialization expected in ambient declarations declare const c1: boolean = true; ~ diff --git a/tests/baselines/reference/constDeclarations-ambient-errors.js b/tests/baselines/reference/constDeclarations-ambient-errors.js index e6e7ac1fb16..7e506c85cf1 100644 --- a/tests/baselines/reference/constDeclarations-ambient-errors.js +++ b/tests/baselines/reference/constDeclarations-ambient-errors.js @@ -1,5 +1,4 @@ //// [constDeclarations-ambient-errors.ts] - // error: no intialization expected in ambient declarations declare const c1: boolean = true; declare const c2: number = 0; diff --git a/tests/baselines/reference/constDeclarations-ambient.js b/tests/baselines/reference/constDeclarations-ambient.js index dd78f73051a..eb31d0c61d8 100644 --- a/tests/baselines/reference/constDeclarations-ambient.js +++ b/tests/baselines/reference/constDeclarations-ambient.js @@ -1,5 +1,4 @@ //// [constDeclarations-ambient.ts] - // No error declare const c1: boolean; declare const c2: number; diff --git a/tests/baselines/reference/constDeclarations-ambient.symbols b/tests/baselines/reference/constDeclarations-ambient.symbols index 87dfecab0c0..e9a41a706c6 100644 --- a/tests/baselines/reference/constDeclarations-ambient.symbols +++ b/tests/baselines/reference/constDeclarations-ambient.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/constDeclarations-ambient.ts === - // No error declare const c1: boolean; ->c1 : Symbol(c1, Decl(constDeclarations-ambient.ts, 2, 13)) +>c1 : Symbol(c1, Decl(constDeclarations-ambient.ts, 1, 13)) declare const c2: number; ->c2 : Symbol(c2, Decl(constDeclarations-ambient.ts, 3, 13)) +>c2 : Symbol(c2, Decl(constDeclarations-ambient.ts, 2, 13)) declare const c3, c4 :string, c5: any; ->c3 : Symbol(c3, Decl(constDeclarations-ambient.ts, 4, 13)) ->c4 : Symbol(c4, Decl(constDeclarations-ambient.ts, 4, 17)) ->c5 : Symbol(c5, Decl(constDeclarations-ambient.ts, 4, 29)) +>c3 : Symbol(c3, Decl(constDeclarations-ambient.ts, 3, 13)) +>c4 : Symbol(c4, Decl(constDeclarations-ambient.ts, 3, 17)) +>c5 : Symbol(c5, Decl(constDeclarations-ambient.ts, 3, 29)) declare module M { ->M : Symbol(M, Decl(constDeclarations-ambient.ts, 4, 38)) +>M : Symbol(M, Decl(constDeclarations-ambient.ts, 3, 38)) const c6; ->c6 : Symbol(c6, Decl(constDeclarations-ambient.ts, 7, 9)) +>c6 : Symbol(c6, Decl(constDeclarations-ambient.ts, 6, 9)) const c7: number; ->c7 : Symbol(c7, Decl(constDeclarations-ambient.ts, 8, 9)) +>c7 : Symbol(c7, Decl(constDeclarations-ambient.ts, 7, 9)) } diff --git a/tests/baselines/reference/constDeclarations-ambient.types b/tests/baselines/reference/constDeclarations-ambient.types index 0ab2d4b700a..f9db4f11d49 100644 --- a/tests/baselines/reference/constDeclarations-ambient.types +++ b/tests/baselines/reference/constDeclarations-ambient.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations-ambient.ts === - // No error declare const c1: boolean; >c1 : boolean diff --git a/tests/baselines/reference/constDeclarations-errors.errors.txt b/tests/baselines/reference/constDeclarations-errors.errors.txt index 14a3de1bf81..52579561707 100644 --- a/tests/baselines/reference/constDeclarations-errors.errors.txt +++ b/tests/baselines/reference/constDeclarations-errors.errors.txt @@ -1,16 +1,15 @@ +tests/cases/compiler/constDeclarations-errors.ts(2,7): error TS1155: 'const' declarations must be initialized. tests/cases/compiler/constDeclarations-errors.ts(3,7): error TS1155: 'const' declarations must be initialized. tests/cases/compiler/constDeclarations-errors.ts(4,7): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,7): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,11): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,15): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,27): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(10,27): error TS2540: Cannot assign to 'c8' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-errors.ts(13,11): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(16,20): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(4,11): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(4,15): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(4,27): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(9,27): error TS2540: Cannot assign to 'c8' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-errors.ts(12,11): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(15,20): error TS1155: 'const' declarations must be initialized. ==== tests/cases/compiler/constDeclarations-errors.ts (9 errors) ==== - // error, missing intialicer const c1; ~~ diff --git a/tests/baselines/reference/constDeclarations-errors.js b/tests/baselines/reference/constDeclarations-errors.js index e7143f2564a..afd0fcacf28 100644 --- a/tests/baselines/reference/constDeclarations-errors.js +++ b/tests/baselines/reference/constDeclarations-errors.js @@ -1,5 +1,4 @@ //// [constDeclarations-errors.ts] - // error, missing intialicer const c1; const c2: number; diff --git a/tests/baselines/reference/constDeclarations-es5.js b/tests/baselines/reference/constDeclarations-es5.js index 736260ad102..f8d8cdeac90 100644 --- a/tests/baselines/reference/constDeclarations-es5.js +++ b/tests/baselines/reference/constDeclarations-es5.js @@ -1,5 +1,4 @@ //// [constDeclarations-es5.ts] - const z7 = false; const z8: number = 23; const z9 = 0, z10 :string = "", z11 = null; diff --git a/tests/baselines/reference/constDeclarations-es5.symbols b/tests/baselines/reference/constDeclarations-es5.symbols index 116dd06573b..93a7d90ec4a 100644 --- a/tests/baselines/reference/constDeclarations-es5.symbols +++ b/tests/baselines/reference/constDeclarations-es5.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/constDeclarations-es5.ts === - const z7 = false; ->z7 : Symbol(z7, Decl(constDeclarations-es5.ts, 1, 5)) +>z7 : Symbol(z7, Decl(constDeclarations-es5.ts, 0, 5)) const z8: number = 23; ->z8 : Symbol(z8, Decl(constDeclarations-es5.ts, 2, 5)) +>z8 : Symbol(z8, Decl(constDeclarations-es5.ts, 1, 5)) const z9 = 0, z10 :string = "", z11 = null; ->z9 : Symbol(z9, Decl(constDeclarations-es5.ts, 3, 5)) ->z10 : Symbol(z10, Decl(constDeclarations-es5.ts, 3, 13)) ->z11 : Symbol(z11, Decl(constDeclarations-es5.ts, 3, 31)) +>z9 : Symbol(z9, Decl(constDeclarations-es5.ts, 2, 5)) +>z10 : Symbol(z10, Decl(constDeclarations-es5.ts, 2, 13)) +>z11 : Symbol(z11, Decl(constDeclarations-es5.ts, 2, 31)) diff --git a/tests/baselines/reference/constDeclarations-es5.types b/tests/baselines/reference/constDeclarations-es5.types index e801607727e..49e97207845 100644 --- a/tests/baselines/reference/constDeclarations-es5.types +++ b/tests/baselines/reference/constDeclarations-es5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations-es5.ts === - const z7 = false; >z7 : false >false : false diff --git a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt index 93a5644abb5..976732f245f 100644 --- a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt +++ b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt @@ -1,16 +1,15 @@ -tests/cases/compiler/constDeclarations-invalidContexts.ts(4,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(6,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(9,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(12,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(16,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/compiler/constDeclarations-invalidContexts.ts(20,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(23,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(26,12): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(3,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(5,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(8,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(11,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(15,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/constDeclarations-invalidContexts.ts(19,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(22,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(25,12): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(28,29): error TS1156: 'const' declarations can only be declared inside a block. ==== tests/cases/compiler/constDeclarations-invalidContexts.ts (9 errors) ==== - // Errors, const must be defined inside a block if (true) const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-invalidContexts.js b/tests/baselines/reference/constDeclarations-invalidContexts.js index a9dc1b47145..2a3dad8df50 100644 --- a/tests/baselines/reference/constDeclarations-invalidContexts.js +++ b/tests/baselines/reference/constDeclarations-invalidContexts.js @@ -1,5 +1,4 @@ //// [constDeclarations-invalidContexts.ts] - // Errors, const must be defined inside a block if (true) const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-scopes.errors.txt b/tests/baselines/reference/constDeclarations-scopes.errors.txt index 905988bf784..064ad9aaaf8 100644 --- a/tests/baselines/reference/constDeclarations-scopes.errors.txt +++ b/tests/baselines/reference/constDeclarations-scopes.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/constDeclarations-scopes.ts(13,5): error TS7027: Unreachable code detected. -tests/cases/compiler/constDeclarations-scopes.ts(22,1): error TS7027: Unreachable code detected. -tests/cases/compiler/constDeclarations-scopes.ts(28,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/constDeclarations-scopes.ts(12,5): error TS7027: Unreachable code detected. +tests/cases/compiler/constDeclarations-scopes.ts(21,1): error TS7027: Unreachable code detected. +tests/cases/compiler/constDeclarations-scopes.ts(27,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/constDeclarations-scopes.ts (3 errors) ==== - // global const c = "string"; diff --git a/tests/baselines/reference/constDeclarations-scopes.js b/tests/baselines/reference/constDeclarations-scopes.js index b144b4f83a5..a40edb87ec9 100644 --- a/tests/baselines/reference/constDeclarations-scopes.js +++ b/tests/baselines/reference/constDeclarations-scopes.js @@ -1,5 +1,4 @@ //// [constDeclarations-scopes.ts] - // global const c = "string"; diff --git a/tests/baselines/reference/constDeclarations-scopes2.js b/tests/baselines/reference/constDeclarations-scopes2.js index d407cf56801..03d78f9030e 100644 --- a/tests/baselines/reference/constDeclarations-scopes2.js +++ b/tests/baselines/reference/constDeclarations-scopes2.js @@ -1,5 +1,4 @@ //// [constDeclarations-scopes2.ts] - // global const c = "string"; diff --git a/tests/baselines/reference/constDeclarations-scopes2.symbols b/tests/baselines/reference/constDeclarations-scopes2.symbols index 15e466e8ea1..60eb7606d0e 100644 --- a/tests/baselines/reference/constDeclarations-scopes2.symbols +++ b/tests/baselines/reference/constDeclarations-scopes2.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/constDeclarations-scopes2.ts === - // global const c = "string"; ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 2, 5)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 1, 5)) var n: number; ->n : Symbol(n, Decl(constDeclarations-scopes2.ts, 4, 3)) +>n : Symbol(n, Decl(constDeclarations-scopes2.ts, 3, 3)) var b: boolean; ->b : Symbol(b, Decl(constDeclarations-scopes2.ts, 5, 3)) +>b : Symbol(b, Decl(constDeclarations-scopes2.ts, 4, 3)) // for scope for (const c = 0; c < 10; n = c ) { ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 8, 10)) ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 8, 10)) ->n : Symbol(n, Decl(constDeclarations-scopes2.ts, 4, 3)) ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 8, 10)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 7, 10)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 7, 10)) +>n : Symbol(n, Decl(constDeclarations-scopes2.ts, 3, 3)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 7, 10)) // for block const c = false; ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 10, 9)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 9, 9)) b = c; ->b : Symbol(b, Decl(constDeclarations-scopes2.ts, 5, 3)) ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 10, 9)) +>b : Symbol(b, Decl(constDeclarations-scopes2.ts, 4, 3)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 9, 9)) } diff --git a/tests/baselines/reference/constDeclarations-scopes2.types b/tests/baselines/reference/constDeclarations-scopes2.types index 9834c6bb16e..98e27785563 100644 --- a/tests/baselines/reference/constDeclarations-scopes2.types +++ b/tests/baselines/reference/constDeclarations-scopes2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations-scopes2.ts === - // global const c = "string"; >c : "string" diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt b/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt index 97cf58c6e9d..a4d33065b59 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(3,5): error TS2448: Block-scoped variable 'c1' used before its declaration. -tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(9,5): error TS2448: Block-scoped variable 'v1' used before its declaration. +tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(2,5): error TS2448: Block-scoped variable 'c1' used before its declaration. +tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(8,5): error TS2448: Block-scoped variable 'v1' used before its declaration. ==== tests/cases/compiler/constDeclarations-useBeforeDefinition.ts (2 errors) ==== - { c1; ~~ diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition.js b/tests/baselines/reference/constDeclarations-useBeforeDefinition.js index 4fe0e64f275..251526c0174 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition.js +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition.js @@ -1,5 +1,4 @@ //// [constDeclarations-useBeforeDefinition.ts] - { c1; const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt index a4d28f51878..bbcc3b2c8f8 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'c' used before its declaration. +tests/cases/compiler/file1.ts(1,1): error TS2448: Block-scoped variable 'c' used before its declaration. ==== tests/cases/compiler/file1.ts (1 errors) ==== - c; ~ !!! error TS2448: Block-scoped variable 'c' used before its declaration. diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js index 7d1f4cf5725..022bd25409a 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/constDeclarations-useBeforeDefinition2.ts] //// //// [file1.ts] - c; //// [file2.ts] diff --git a/tests/baselines/reference/constDeclarations-validContexts.errors.txt b/tests/baselines/reference/constDeclarations-validContexts.errors.txt index 65e80e7c6fd..58ad3ee9903 100644 --- a/tests/baselines/reference/constDeclarations-validContexts.errors.txt +++ b/tests/baselines/reference/constDeclarations-validContexts.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/constDeclarations-validContexts.ts(20,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/constDeclarations-validContexts.ts(18,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/constDeclarations-validContexts.ts (1 errors) ==== - - // Control flow statements with blocks if (true) { const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-validContexts.js b/tests/baselines/reference/constDeclarations-validContexts.js index 7d3269c6683..dba61fec635 100644 --- a/tests/baselines/reference/constDeclarations-validContexts.js +++ b/tests/baselines/reference/constDeclarations-validContexts.js @@ -1,6 +1,4 @@ //// [constDeclarations-validContexts.ts] - - // Control flow statements with blocks if (true) { const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations.js b/tests/baselines/reference/constDeclarations.js index 00d0a61ef9b..27365117942 100644 --- a/tests/baselines/reference/constDeclarations.js +++ b/tests/baselines/reference/constDeclarations.js @@ -1,5 +1,4 @@ //// [constDeclarations.ts] - // No error const c1 = false; const c2: number = 23; diff --git a/tests/baselines/reference/constDeclarations.symbols b/tests/baselines/reference/constDeclarations.symbols index 01653620dd0..2ec87cedb7e 100644 --- a/tests/baselines/reference/constDeclarations.symbols +++ b/tests/baselines/reference/constDeclarations.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/constDeclarations.ts === - // No error const c1 = false; ->c1 : Symbol(c1, Decl(constDeclarations.ts, 2, 5)) +>c1 : Symbol(c1, Decl(constDeclarations.ts, 1, 5)) const c2: number = 23; ->c2 : Symbol(c2, Decl(constDeclarations.ts, 3, 5)) +>c2 : Symbol(c2, Decl(constDeclarations.ts, 2, 5)) const c3 = 0, c4 :string = "", c5 = null; ->c3 : Symbol(c3, Decl(constDeclarations.ts, 4, 5)) ->c4 : Symbol(c4, Decl(constDeclarations.ts, 4, 13)) ->c5 : Symbol(c5, Decl(constDeclarations.ts, 4, 30)) +>c3 : Symbol(c3, Decl(constDeclarations.ts, 3, 5)) +>c4 : Symbol(c4, Decl(constDeclarations.ts, 3, 13)) +>c5 : Symbol(c5, Decl(constDeclarations.ts, 3, 30)) for(const c4 = 0; c4 < 9; ) { break; } ->c4 : Symbol(c4, Decl(constDeclarations.ts, 7, 9)) ->c4 : Symbol(c4, Decl(constDeclarations.ts, 7, 9)) +>c4 : Symbol(c4, Decl(constDeclarations.ts, 6, 9)) +>c4 : Symbol(c4, Decl(constDeclarations.ts, 6, 9)) for(const c5 = 0, c6 = 0; c5 < c6; ) { break; } ->c5 : Symbol(c5, Decl(constDeclarations.ts, 10, 9)) ->c6 : Symbol(c6, Decl(constDeclarations.ts, 10, 17)) ->c5 : Symbol(c5, Decl(constDeclarations.ts, 10, 9)) ->c6 : Symbol(c6, Decl(constDeclarations.ts, 10, 17)) +>c5 : Symbol(c5, Decl(constDeclarations.ts, 9, 9)) +>c6 : Symbol(c6, Decl(constDeclarations.ts, 9, 17)) +>c5 : Symbol(c5, Decl(constDeclarations.ts, 9, 9)) +>c6 : Symbol(c6, Decl(constDeclarations.ts, 9, 17)) diff --git a/tests/baselines/reference/constDeclarations.types b/tests/baselines/reference/constDeclarations.types index 0fa7893529f..75a9dc7556a 100644 --- a/tests/baselines/reference/constDeclarations.types +++ b/tests/baselines/reference/constDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations.ts === - // No error const c1 = false; >c1 : false diff --git a/tests/baselines/reference/constDeclarations2.js b/tests/baselines/reference/constDeclarations2.js index 0c372924b50..e19022154c0 100644 --- a/tests/baselines/reference/constDeclarations2.js +++ b/tests/baselines/reference/constDeclarations2.js @@ -1,5 +1,4 @@ //// [constDeclarations2.ts] - // No error module M { export const c1 = false; diff --git a/tests/baselines/reference/constDeclarations2.symbols b/tests/baselines/reference/constDeclarations2.symbols index daeced31f77..2772c343e2e 100644 --- a/tests/baselines/reference/constDeclarations2.symbols +++ b/tests/baselines/reference/constDeclarations2.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/constDeclarations2.ts === - // No error module M { >M : Symbol(M, Decl(constDeclarations2.ts, 0, 0)) export const c1 = false; ->c1 : Symbol(c1, Decl(constDeclarations2.ts, 3, 16)) +>c1 : Symbol(c1, Decl(constDeclarations2.ts, 2, 16)) export const c2: number = 23; ->c2 : Symbol(c2, Decl(constDeclarations2.ts, 4, 16)) +>c2 : Symbol(c2, Decl(constDeclarations2.ts, 3, 16)) export const c3 = 0, c4 :string = "", c5 = null; ->c3 : Symbol(c3, Decl(constDeclarations2.ts, 5, 16)) ->c4 : Symbol(c4, Decl(constDeclarations2.ts, 5, 24)) ->c5 : Symbol(c5, Decl(constDeclarations2.ts, 5, 41)) +>c3 : Symbol(c3, Decl(constDeclarations2.ts, 4, 16)) +>c4 : Symbol(c4, Decl(constDeclarations2.ts, 4, 24)) +>c5 : Symbol(c5, Decl(constDeclarations2.ts, 4, 41)) } diff --git a/tests/baselines/reference/constDeclarations2.types b/tests/baselines/reference/constDeclarations2.types index 54a273dfb4d..fdf127cbab4 100644 --- a/tests/baselines/reference/constDeclarations2.types +++ b/tests/baselines/reference/constDeclarations2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations2.ts === - // No error module M { >M : typeof M diff --git a/tests/baselines/reference/constEnum1.js b/tests/baselines/reference/constEnum1.js index d5ccede3ff1..7065c12d8cf 100644 --- a/tests/baselines/reference/constEnum1.js +++ b/tests/baselines/reference/constEnum1.js @@ -1,5 +1,4 @@ //// [constEnum1.ts] - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnum1.symbols b/tests/baselines/reference/constEnum1.symbols index e94ed0a4722..f7593863e8c 100644 --- a/tests/baselines/reference/constEnum1.symbols +++ b/tests/baselines/reference/constEnum1.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnum1.ts === - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. @@ -8,33 +7,33 @@ const enum E { >E : Symbol(E, Decl(constEnum1.ts, 0, 0)) a = 10, ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) b = a, ->b : Symbol(E.b, Decl(constEnum1.ts, 6, 11)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>b : Symbol(E.b, Decl(constEnum1.ts, 5, 11)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) c = (a+1), ->c : Symbol(E.c, Decl(constEnum1.ts, 7, 10)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>c : Symbol(E.c, Decl(constEnum1.ts, 6, 10)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) e, ->e : Symbol(E.e, Decl(constEnum1.ts, 8, 14)) +>e : Symbol(E.e, Decl(constEnum1.ts, 7, 14)) d = ~e, ->d : Symbol(E.d, Decl(constEnum1.ts, 9, 6)) ->e : Symbol(E.e, Decl(constEnum1.ts, 8, 14)) +>d : Symbol(E.d, Decl(constEnum1.ts, 8, 6)) +>e : Symbol(E.e, Decl(constEnum1.ts, 7, 14)) f = a << 2 >> 1, ->f : Symbol(E.f, Decl(constEnum1.ts, 10, 11)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>f : Symbol(E.f, Decl(constEnum1.ts, 9, 11)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) g = a << 2 >>> 1, ->g : Symbol(E.g, Decl(constEnum1.ts, 11, 20)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>g : Symbol(E.g, Decl(constEnum1.ts, 10, 20)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) h = a | b ->h : Symbol(E.h, Decl(constEnum1.ts, 12, 21)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) ->b : Symbol(E.b, Decl(constEnum1.ts, 6, 11)) +>h : Symbol(E.h, Decl(constEnum1.ts, 11, 21)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) +>b : Symbol(E.b, Decl(constEnum1.ts, 5, 11)) } diff --git a/tests/baselines/reference/constEnum1.types b/tests/baselines/reference/constEnum1.types index 17f6f5de278..9df7eff9515 100644 --- a/tests/baselines/reference/constEnum1.types +++ b/tests/baselines/reference/constEnum1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnum1.ts === - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnum2.errors.txt b/tests/baselines/reference/constEnum2.errors.txt index f0cac0c2f5d..cfec4d9055b 100644 --- a/tests/baselines/reference/constEnum2.errors.txt +++ b/tests/baselines/reference/constEnum2.errors.txt @@ -1,11 +1,10 @@ +tests/cases/conformance/constEnums/constEnum2.ts(10,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. tests/cases/conformance/constEnums/constEnum2.ts(11,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. +tests/cases/conformance/constEnums/constEnum2.ts(12,5): error TS1005: ',' expected. tests/cases/conformance/constEnums/constEnum2.ts(12,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. -tests/cases/conformance/constEnums/constEnum2.ts(13,5): error TS1005: ',' expected. -tests/cases/conformance/constEnums/constEnum2.ts(13,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. ==== tests/cases/conformance/constEnums/constEnum2.ts (4 errors) ==== - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnum2.js b/tests/baselines/reference/constEnum2.js index c0c640b87fd..66a44f6a1be 100644 --- a/tests/baselines/reference/constEnum2.js +++ b/tests/baselines/reference/constEnum2.js @@ -1,5 +1,4 @@ //// [constEnum2.ts] - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnumDeclarations.js b/tests/baselines/reference/constEnumDeclarations.js index 1cbacb13bbd..f24769c4620 100644 --- a/tests/baselines/reference/constEnumDeclarations.js +++ b/tests/baselines/reference/constEnumDeclarations.js @@ -1,5 +1,4 @@ //// [constEnumDeclarations.ts] - const enum E { A = 1, B = 2, diff --git a/tests/baselines/reference/constEnumDeclarations.symbols b/tests/baselines/reference/constEnumDeclarations.symbols index 72b833e4fae..9809e6a2c56 100644 --- a/tests/baselines/reference/constEnumDeclarations.symbols +++ b/tests/baselines/reference/constEnumDeclarations.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/constEnumDeclarations.ts === - const enum E { >E : Symbol(E, Decl(constEnumDeclarations.ts, 0, 0)) A = 1, ->A : Symbol(E.A, Decl(constEnumDeclarations.ts, 1, 14)) +>A : Symbol(E.A, Decl(constEnumDeclarations.ts, 0, 14)) B = 2, ->B : Symbol(E.B, Decl(constEnumDeclarations.ts, 2, 10)) +>B : Symbol(E.B, Decl(constEnumDeclarations.ts, 1, 10)) C = A | B ->C : Symbol(E.C, Decl(constEnumDeclarations.ts, 3, 10)) ->A : Symbol(E.A, Decl(constEnumDeclarations.ts, 1, 14)) ->B : Symbol(E.B, Decl(constEnumDeclarations.ts, 2, 10)) +>C : Symbol(E.C, Decl(constEnumDeclarations.ts, 2, 10)) +>A : Symbol(E.A, Decl(constEnumDeclarations.ts, 0, 14)) +>B : Symbol(E.B, Decl(constEnumDeclarations.ts, 1, 10)) } const enum E2 { ->E2 : Symbol(E2, Decl(constEnumDeclarations.ts, 5, 1)) +>E2 : Symbol(E2, Decl(constEnumDeclarations.ts, 4, 1)) A = 1, ->A : Symbol(E2.A, Decl(constEnumDeclarations.ts, 7, 15)) +>A : Symbol(E2.A, Decl(constEnumDeclarations.ts, 6, 15)) B, ->B : Symbol(E2.B, Decl(constEnumDeclarations.ts, 8, 10)) +>B : Symbol(E2.B, Decl(constEnumDeclarations.ts, 7, 10)) C ->C : Symbol(E2.C, Decl(constEnumDeclarations.ts, 9, 6)) +>C : Symbol(E2.C, Decl(constEnumDeclarations.ts, 8, 6)) } diff --git a/tests/baselines/reference/constEnumDeclarations.types b/tests/baselines/reference/constEnumDeclarations.types index 1f86028b385..c8bf3698d19 100644 --- a/tests/baselines/reference/constEnumDeclarations.types +++ b/tests/baselines/reference/constEnumDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constEnumDeclarations.ts === - const enum E { >E : E diff --git a/tests/baselines/reference/constEnumMergingWithValues1.js b/tests/baselines/reference/constEnumMergingWithValues1.js index 1fdfb3fb1dd..a9c1eef8de8 100644 --- a/tests/baselines/reference/constEnumMergingWithValues1.js +++ b/tests/baselines/reference/constEnumMergingWithValues1.js @@ -1,5 +1,4 @@ //// [m1.ts] - function foo() {} module foo { const enum E { X } diff --git a/tests/baselines/reference/constEnumMergingWithValues1.symbols b/tests/baselines/reference/constEnumMergingWithValues1.symbols index ba655091ded..9be1d9698bf 100644 --- a/tests/baselines/reference/constEnumMergingWithValues1.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues1.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/m1.ts === - function foo() {} ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 17)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 17)) module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 17)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 17)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 2, 12)) ->X : Symbol(E.X, Decl(m1.ts, 3, 18)) +>E : Symbol(E, Decl(m1.ts, 1, 12)) +>X : Symbol(E.X, Decl(m1.ts, 2, 18)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 17)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 17)) diff --git a/tests/baselines/reference/constEnumMergingWithValues1.types b/tests/baselines/reference/constEnumMergingWithValues1.types index c5b1a82a5a8..44d6e5c9ac3 100644 --- a/tests/baselines/reference/constEnumMergingWithValues1.types +++ b/tests/baselines/reference/constEnumMergingWithValues1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - function foo() {} >foo : typeof foo diff --git a/tests/baselines/reference/constEnumMergingWithValues2.js b/tests/baselines/reference/constEnumMergingWithValues2.js index 07249ddcc5f..bd14cf1eda1 100644 --- a/tests/baselines/reference/constEnumMergingWithValues2.js +++ b/tests/baselines/reference/constEnumMergingWithValues2.js @@ -1,5 +1,4 @@ //// [m1.ts] - class foo {} module foo { const enum E { X } diff --git a/tests/baselines/reference/constEnumMergingWithValues2.symbols b/tests/baselines/reference/constEnumMergingWithValues2.symbols index a7744499f49..60bfbd64753 100644 --- a/tests/baselines/reference/constEnumMergingWithValues2.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues2.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/m1.ts === - class foo {} ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 12)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 12)) module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 12)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 12)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 2, 12)) ->X : Symbol(E.X, Decl(m1.ts, 3, 18)) +>E : Symbol(E, Decl(m1.ts, 1, 12)) +>X : Symbol(E.X, Decl(m1.ts, 2, 18)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 12)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 12)) diff --git a/tests/baselines/reference/constEnumMergingWithValues2.types b/tests/baselines/reference/constEnumMergingWithValues2.types index ab2372cbae9..88a2413094b 100644 --- a/tests/baselines/reference/constEnumMergingWithValues2.types +++ b/tests/baselines/reference/constEnumMergingWithValues2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - class foo {} >foo : foo diff --git a/tests/baselines/reference/constEnumMergingWithValues3.js b/tests/baselines/reference/constEnumMergingWithValues3.js index c2cafb2a5f1..7e105976d2d 100644 --- a/tests/baselines/reference/constEnumMergingWithValues3.js +++ b/tests/baselines/reference/constEnumMergingWithValues3.js @@ -1,5 +1,4 @@ //// [m1.ts] - enum foo { A } module foo { const enum E { X } diff --git a/tests/baselines/reference/constEnumMergingWithValues3.symbols b/tests/baselines/reference/constEnumMergingWithValues3.symbols index 816919c6805..dfb5cc7bd40 100644 --- a/tests/baselines/reference/constEnumMergingWithValues3.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues3.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/m1.ts === - enum foo { A } ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 14)) ->A : Symbol(foo.A, Decl(m1.ts, 1, 10)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 14)) +>A : Symbol(foo.A, Decl(m1.ts, 0, 10)) module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 14)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 14)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 2, 12)) ->X : Symbol(E.X, Decl(m1.ts, 3, 18)) +>E : Symbol(E, Decl(m1.ts, 1, 12)) +>X : Symbol(E.X, Decl(m1.ts, 2, 18)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 14)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 14)) diff --git a/tests/baselines/reference/constEnumMergingWithValues3.types b/tests/baselines/reference/constEnumMergingWithValues3.types index 392772860e4..6346f06ce81 100644 --- a/tests/baselines/reference/constEnumMergingWithValues3.types +++ b/tests/baselines/reference/constEnumMergingWithValues3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - enum foo { A } >foo : foo >A : foo diff --git a/tests/baselines/reference/constEnumMergingWithValues4.js b/tests/baselines/reference/constEnumMergingWithValues4.js index c297b834654..3d70f5ad2c9 100644 --- a/tests/baselines/reference/constEnumMergingWithValues4.js +++ b/tests/baselines/reference/constEnumMergingWithValues4.js @@ -1,5 +1,4 @@ //// [m1.ts] - module foo { const enum E { X } } diff --git a/tests/baselines/reference/constEnumMergingWithValues4.symbols b/tests/baselines/reference/constEnumMergingWithValues4.symbols index a7135b53d57..b7ebcdb609a 100644 --- a/tests/baselines/reference/constEnumMergingWithValues4.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues4.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/m1.ts === - module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 3, 1)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 2, 1)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 1, 12)) ->X : Symbol(E.X, Decl(m1.ts, 2, 18)) +>E : Symbol(E, Decl(m1.ts, 0, 12)) +>X : Symbol(E.X, Decl(m1.ts, 1, 18)) } module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 3, 1)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 2, 1)) var x = 1; ->x : Symbol(x, Decl(m1.ts, 6, 7)) +>x : Symbol(x, Decl(m1.ts, 5, 7)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 3, 1)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 2, 1)) diff --git a/tests/baselines/reference/constEnumMergingWithValues4.types b/tests/baselines/reference/constEnumMergingWithValues4.types index 8df07d3026d..1e82bb48791 100644 --- a/tests/baselines/reference/constEnumMergingWithValues4.types +++ b/tests/baselines/reference/constEnumMergingWithValues4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - module foo { >foo : typeof foo diff --git a/tests/baselines/reference/constEnumMergingWithValues5.js b/tests/baselines/reference/constEnumMergingWithValues5.js index 45aeff7bba3..50a6e5c6925 100644 --- a/tests/baselines/reference/constEnumMergingWithValues5.js +++ b/tests/baselines/reference/constEnumMergingWithValues5.js @@ -1,5 +1,4 @@ //// [m1.ts] - module foo { const enum E { X } } diff --git a/tests/baselines/reference/constEnumMergingWithValues5.symbols b/tests/baselines/reference/constEnumMergingWithValues5.symbols index 257e1897e5c..23c25fce8a0 100644 --- a/tests/baselines/reference/constEnumMergingWithValues5.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues5.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/m1.ts === - module foo { >foo : Symbol(foo, Decl(m1.ts, 0, 0)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 1, 12)) ->X : Symbol(E.X, Decl(m1.ts, 2, 18)) +>E : Symbol(E, Decl(m1.ts, 0, 12)) +>X : Symbol(E.X, Decl(m1.ts, 1, 18)) } export = foo diff --git a/tests/baselines/reference/constEnumMergingWithValues5.types b/tests/baselines/reference/constEnumMergingWithValues5.types index 585363f4d97..194e85e6965 100644 --- a/tests/baselines/reference/constEnumMergingWithValues5.types +++ b/tests/baselines/reference/constEnumMergingWithValues5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - module foo { >foo : typeof foo diff --git a/tests/baselines/reference/constEnumPropertyAccess1.js b/tests/baselines/reference/constEnumPropertyAccess1.js index 114f1e1928e..66ac7b4a459 100644 --- a/tests/baselines/reference/constEnumPropertyAccess1.js +++ b/tests/baselines/reference/constEnumPropertyAccess1.js @@ -1,5 +1,4 @@ //// [constEnumPropertyAccess1.ts] - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constEnumPropertyAccess1.symbols b/tests/baselines/reference/constEnumPropertyAccess1.symbols index e5f2853f157..63861a94ae1 100644 --- a/tests/baselines/reference/constEnumPropertyAccess1.symbols +++ b/tests/baselines/reference/constEnumPropertyAccess1.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnumPropertyAccess1.ts === - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members @@ -8,69 +7,69 @@ const enum G { >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) A = 1, ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) B = 2, ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) C = A + B, ->C : Symbol(G.C, Decl(constEnumPropertyAccess1.ts, 7, 10)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>C : Symbol(G.C, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) D = A * 2 ->D : Symbol(G.D, Decl(constEnumPropertyAccess1.ts, 8, 14)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>D : Symbol(G.D, Decl(constEnumPropertyAccess1.ts, 7, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) } var o: { ->o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 12, 3)) +>o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 11, 3)) [idx: number]: boolean ->idx : Symbol(idx, Decl(constEnumPropertyAccess1.ts, 13, 5)) +>idx : Symbol(idx, Decl(constEnumPropertyAccess1.ts, 12, 5)) } = { 1: true }; var a = G.A; ->a : Symbol(a, Decl(constEnumPropertyAccess1.ts, 18, 3)) ->G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>a : Symbol(a, Decl(constEnumPropertyAccess1.ts, 17, 3)) +>G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) var a1 = G["A"]; ->a1 : Symbol(a1, Decl(constEnumPropertyAccess1.ts, 19, 3)) +>a1 : Symbol(a1, Decl(constEnumPropertyAccess1.ts, 18, 3)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->"A" : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>"A" : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) var g = o[G.A]; ->g : Symbol(g, Decl(constEnumPropertyAccess1.ts, 20, 3)) ->o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 12, 3)) ->G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>g : Symbol(g, Decl(constEnumPropertyAccess1.ts, 19, 3)) +>o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 11, 3)) +>G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) class C { ->C : Symbol(C, Decl(constEnumPropertyAccess1.ts, 20, 15)) +>C : Symbol(C, Decl(constEnumPropertyAccess1.ts, 19, 15)) [G.A]() { } ->G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) get [G.B]() { ->G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) return true; } set [G.B](x: number) { } ->G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) ->x : Symbol(x, Decl(constEnumPropertyAccess1.ts, 27, 14)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) +>x : Symbol(x, Decl(constEnumPropertyAccess1.ts, 26, 14)) } diff --git a/tests/baselines/reference/constEnumPropertyAccess1.types b/tests/baselines/reference/constEnumPropertyAccess1.types index 869a31d5e1f..af9aacd279c 100644 --- a/tests/baselines/reference/constEnumPropertyAccess1.types +++ b/tests/baselines/reference/constEnumPropertyAccess1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnumPropertyAccess1.ts === - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constEnumPropertyAccess2.errors.txt b/tests/baselines/reference/constEnumPropertyAccess2.errors.txt index 9f16059ff2f..aa08c11c7a2 100644 --- a/tests/baselines/reference/constEnumPropertyAccess2.errors.txt +++ b/tests/baselines/reference/constEnumPropertyAccess2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(14,9): error TS2475: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(15,12): error TS2476: A const enum member can only be accessed using a string literal. -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(17,1): error TS2322: Type '"string"' is not assignable to type 'G'. -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(19,3): error TS2540: Cannot assign to 'B' because it is a constant or a read-only property. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(13,9): error TS2475: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(14,12): error TS2476: A const enum member can only be accessed using a string literal. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(16,1): error TS2322: Type '"string"' is not assignable to type 'G'. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(18,3): error TS2540: Cannot assign to 'B' because it is a constant or a read-only property. ==== tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts (4 errors) ==== - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constEnumPropertyAccess2.js b/tests/baselines/reference/constEnumPropertyAccess2.js index 46a1d918b94..f16eda4bf2d 100644 --- a/tests/baselines/reference/constEnumPropertyAccess2.js +++ b/tests/baselines/reference/constEnumPropertyAccess2.js @@ -1,5 +1,4 @@ //// [constEnumPropertyAccess2.ts] - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constIndexedAccess.js b/tests/baselines/reference/constIndexedAccess.js index db80441bd33..ea203c38e3f 100644 --- a/tests/baselines/reference/constIndexedAccess.js +++ b/tests/baselines/reference/constIndexedAccess.js @@ -1,5 +1,4 @@ //// [constIndexedAccess.ts] - const enum numbers { zero, one diff --git a/tests/baselines/reference/constIndexedAccess.symbols b/tests/baselines/reference/constIndexedAccess.symbols index f7ce6b78c2d..ef2be6368e3 100644 --- a/tests/baselines/reference/constIndexedAccess.symbols +++ b/tests/baselines/reference/constIndexedAccess.symbols @@ -1,83 +1,82 @@ === tests/cases/compiler/constIndexedAccess.ts === - const enum numbers { >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) zero, ->zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) one ->one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) } interface indexAccess { ->indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1)) +>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 3, 1)) 0: string; 1: number; } let test: indexAccess; ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 3, 1)) let s = test[0]; ->s : Symbol(s, Decl(constIndexedAccess.ts, 13, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->0 : Symbol(indexAccess[0], Decl(constIndexedAccess.ts, 6, 23)) +>s : Symbol(s, Decl(constIndexedAccess.ts, 12, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>0 : Symbol(indexAccess[0], Decl(constIndexedAccess.ts, 5, 23)) let n = test[1]; ->n : Symbol(n, Decl(constIndexedAccess.ts, 14, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->1 : Symbol(indexAccess[1], Decl(constIndexedAccess.ts, 7, 14)) +>n : Symbol(n, Decl(constIndexedAccess.ts, 13, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>1 : Symbol(indexAccess[1], Decl(constIndexedAccess.ts, 6, 14)) let s1 = test[numbers.zero]; ->s1 : Symbol(s1, Decl(constIndexedAccess.ts, 16, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbers.zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>s1 : Symbol(s1, Decl(constIndexedAccess.ts, 15, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbers.zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) let n1 = test[numbers.one]; ->n1 : Symbol(n1, Decl(constIndexedAccess.ts, 17, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbers.one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>n1 : Symbol(n1, Decl(constIndexedAccess.ts, 16, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbers.one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) let s2 = test[numbers["zero"]]; ->s2 : Symbol(s2, Decl(constIndexedAccess.ts, 19, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>s2 : Symbol(s2, Decl(constIndexedAccess.ts, 18, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) let n2 = test[numbers["one"]]; ->n2 : Symbol(n2, Decl(constIndexedAccess.ts, 20, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>n2 : Symbol(n2, Decl(constIndexedAccess.ts, 19, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) enum numbersNotConst { ->numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 19, 30)) zero, ->zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) +>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 21, 22)) one ->one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9)) +>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 22, 9)) } let s3 = test[numbersNotConst.zero]; ->s3 : Symbol(s3, Decl(constIndexedAccess.ts, 27, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbersNotConst.zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) ->numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) ->zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) +>s3 : Symbol(s3, Decl(constIndexedAccess.ts, 26, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbersNotConst.zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 21, 22)) +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 19, 30)) +>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 21, 22)) let n3 = test[numbersNotConst.one]; ->n3 : Symbol(n3, Decl(constIndexedAccess.ts, 28, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbersNotConst.one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9)) ->numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) ->one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9)) +>n3 : Symbol(n3, Decl(constIndexedAccess.ts, 27, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbersNotConst.one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 22, 9)) +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 19, 30)) +>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 22, 9)) diff --git a/tests/baselines/reference/constIndexedAccess.types b/tests/baselines/reference/constIndexedAccess.types index 9e08cf08f49..e63852c1ab1 100644 --- a/tests/baselines/reference/constIndexedAccess.types +++ b/tests/baselines/reference/constIndexedAccess.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constIndexedAccess.ts === - const enum numbers { >numbers : numbers diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt b/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt index aae5f9aac42..ef088d89351 100644 --- a/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt +++ b/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts(4,1): error TS1238: Unable to resolve signature of class decorator when called as an expression. +tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts(3,1): error TS1238: Unable to resolve signature of class decorator when called as an expression. Cannot invoke an expression whose type lacks a call signature. Type 'typeof CtorDtor' has no compatible call signatures. ==== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts (1 errors) ==== - class CtorDtor {} @CtorDtor diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.js b/tests/baselines/reference/constructableDecoratorOnClass01.js index 290c36bb830..858d67923af 100644 --- a/tests/baselines/reference/constructableDecoratorOnClass01.js +++ b/tests/baselines/reference/constructableDecoratorOnClass01.js @@ -1,5 +1,4 @@ //// [constructableDecoratorOnClass01.ts] - class CtorDtor {} @CtorDtor diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt index 2854e73d935..a572e0b34c8 100644 --- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt +++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt @@ -1,94 +1,93 @@ -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2304: Cannot find name 'module'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2503: Cannot find namespace 'module'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,19): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,35): error TS1005: ')' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,28): error TS1005: ':' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,29): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,18): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,26): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(29,30): error TS1005: '=' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(32,18): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,26): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,28): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(36,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(39,17): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,28): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,41): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,45): error TS1002: Unterminated string literal. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(42,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(48,17): error TS2304: Cannot find name 'console'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(50,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(54,13): error TS2304: Cannot find name 'console'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(59,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(70,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(73,37): error TS1127: Invalid character. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(82,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,23): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(91,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,29): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(107,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(109,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(139,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(142,32): error TS1005: '{' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(144,13): error TS1005: 'try' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,24): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,30): error TS1005: '(' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,31): error TS2304: Cannot find name 'Property'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(167,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(182,13): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(184,13): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(188,13): error TS2322: Type 'true' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(192,13): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(206,28): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(214,16): error TS2304: Cannot find name 'bool'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(219,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(224,23): error TS2304: Cannot find name 'bool'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(228,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,14): error TS1005: '{' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,16): error TS2304: Cannot find name 'method1'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,24): error TS2304: Cannot find name 'val'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,27): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,28): error TS2304: Cannot find name 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,36): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,16): error TS2304: Cannot find name 'method2'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,26): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(242,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(247,25): error TS2339: Property 'method1' does not exist on type 'B'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,9): error TS2390: Constructor implementation is missing. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,21): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,44): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,69): error TS1110: Type expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2304: Cannot find name 'module'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,28): error TS1005: ':' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,29): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,18): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,26): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,30): error TS1005: '=' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(31,18): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,26): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,28): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(38,17): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,28): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,41): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,45): error TS1002: Unterminated string literal. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(47,17): error TS2304: Cannot find name 'console'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(49,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(53,13): error TS2304: Cannot find name 'console'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(58,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(69,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(72,37): error TS1127: Invalid character. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(81,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(89,23): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(105,29): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(108,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(138,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(141,32): error TS1005: '{' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(143,13): error TS1005: 'try' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,24): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,30): error TS1005: '(' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,31): error TS2304: Cannot find name 'Property'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(166,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(180,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,13): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(183,13): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(187,13): error TS2322: Type 'true' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(191,13): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(205,28): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(213,16): error TS2304: Cannot find name 'bool'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(218,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(223,23): error TS2304: Cannot find name 'bool'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(227,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(234,14): error TS1005: '{' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,16): error TS2304: Cannot find name 'method1'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,24): error TS2304: Cannot find name 'val'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,27): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,28): error TS2304: Cannot find name 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,36): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,16): error TS2304: Cannot find name 'method2'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,26): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(241,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(246,25): error TS2339: Property 'method1' does not exist on type 'B'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,9): error TS2390: Constructor implementation is missing. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,21): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,44): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,69): error TS1110: Type expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,16): error TS2304: Cannot find name 'Overloads'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,26): error TS2304: Cannot find name 'value'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,31): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,33): error TS2304: Cannot find name 'string'. tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,9): error TS1128: Declaration or statement expected. tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,16): error TS2304: Cannot find name 'Overloads'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,26): error TS2304: Cannot find name 'value'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,31): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,16): error TS2304: Cannot find name 'Overloads'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,27): error TS1135: Argument expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,33): error TS1005: '(' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,35): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,43): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,52): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,60): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,65): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,9): error TS2304: Cannot find name 'public'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS2304: Cannot find name 'DefaultValue'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,29): error TS2304: Cannot find name 'value'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,35): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,37): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,55): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(262,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,27): error TS1135: Argument expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS1005: '(' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,35): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,43): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,52): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,60): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,65): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,9): error TS2304: Cannot find name 'public'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS2304: Cannot find name 'DefaultValue'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,29): error TS2304: Cannot find name 'value'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,35): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,37): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (87 errors) ==== - declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js index afdfa36e4a6..8e9dc6da688 100644 --- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js +++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js @@ -1,5 +1,4 @@ //// [constructorWithIncompleteTypeAnnotation.ts] - declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator01.js b/tests/baselines/reference/contextuallyTypeCommaOperator01.js index 0da3ac91000..f8a9dbe7f8b 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator01.js +++ b/tests/baselines/reference/contextuallyTypeCommaOperator01.js @@ -1,5 +1,4 @@ //// [contextuallyTypeCommaOperator01.ts] - let x: (a: string) => string; x = (100, a => a); diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols b/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols index c07fd28ae77..b3b9326ea82 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols +++ b/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator01.ts === - let x: (a: string) => string; ->x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 1, 3)) ->a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 1, 8)) +>x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 0, 3)) +>a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 0, 8)) x = (100, a => a); ->x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 1, 3)) ->a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 3, 9)) ->a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 3, 9)) +>x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 0, 3)) +>a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 2, 9)) +>a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 2, 9)) diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator01.types b/tests/baselines/reference/contextuallyTypeCommaOperator01.types index 05516949210..febf4c15bf0 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator01.types +++ b/tests/baselines/reference/contextuallyTypeCommaOperator01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator01.ts === - let x: (a: string) => string; >x : (a: string) => string >a : string diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt b/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt index 3214f7e5025..ca958a0521b 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt +++ b/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(4,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. +tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(3,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(4,11): error TS2322: Type 'string' is not assignable to type 'number'. ==== tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts (2 errors) ==== - let x: (a: string) => string; x = (100, a => { diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator02.js b/tests/baselines/reference/contextuallyTypeCommaOperator02.js index 0f8d67dd0ef..1d97d7ccaae 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator02.js +++ b/tests/baselines/reference/contextuallyTypeCommaOperator02.js @@ -1,5 +1,4 @@ //// [contextuallyTypeCommaOperator02.ts] - let x: (a: string) => string; x = (100, a => { diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt b/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt index 715b7cf70ea..4b14c0e1746 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt +++ b/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator03.ts(4,6): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator03.ts(3,6): error TS7006: Parameter 'a' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator03.ts (1 errors) ==== - let x: (a: string) => string; x = (a => a, b => b); diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator03.js b/tests/baselines/reference/contextuallyTypeCommaOperator03.js index c4754f28c41..52ed4d6d363 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator03.js +++ b/tests/baselines/reference/contextuallyTypeCommaOperator03.js @@ -1,5 +1,4 @@ //// [contextuallyTypeCommaOperator03.ts] - let x: (a: string) => string; x = (a => a, b => b); diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd01.js b/tests/baselines/reference/contextuallyTypeLogicalAnd01.js index b8b1f0d1e00..35b509f1192 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd01.js +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd01.js @@ -1,5 +1,4 @@ //// [contextuallyTypeLogicalAnd01.ts] - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols b/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols index 4d69b43e669..a16ba5cc392 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd01.ts === - let x: (a: string) => string; ->x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) ->a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 1, 8)) +>x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 0, 3)) +>a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 0, 8)) let y = true; ->y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 2, 3)) +>y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) x = y && (a => a); ->x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) ->y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 2, 3)) ->a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 4, 10)) ->a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 4, 10)) +>x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 0, 3)) +>y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) +>a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 3, 10)) +>a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 3, 10)) diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd01.types b/tests/baselines/reference/contextuallyTypeLogicalAnd01.types index e55e1e4b511..4ab8849b133 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd01.types +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd01.ts === - let x: (a: string) => string; >x : (a: string) => string >a : string diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt b/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt index 7452d333d88..1d6637d8446 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(5,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. +tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(4,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(6,11): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. ==== tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts (2 errors) ==== - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd02.js b/tests/baselines/reference/contextuallyTypeLogicalAnd02.js index 6dc1fa5b26a..11ec0aa03a8 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd02.js +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd02.js @@ -1,5 +1,4 @@ //// [contextuallyTypeLogicalAnd02.ts] - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt b/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt index 1430be00427..e5256633209 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd03.ts(5,6): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd03.ts(4,6): error TS7006: Parameter 'a' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd03.ts (1 errors) ==== - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd03.js b/tests/baselines/reference/contextuallyTypeLogicalAnd03.js index cbf1b3a319a..67bcb052644 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd03.js +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd03.js @@ -1,5 +1,4 @@ //// [contextuallyTypeLogicalAnd03.ts] - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt index dab85baf2cf..1fef4e61268 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(17,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(20,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(28,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(31,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(39,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(42,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(16,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(19,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(27,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(30,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(38,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(41,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts (6 errors) ==== - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js index a6eaa048093..5b33cc5c799 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js @@ -1,5 +1,4 @@ //// [contextuallyTypedClassExpressionMethodDeclaration01.ts] - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt index ae6dfee4866..207d960ac3c 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(21,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(24,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(32,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(35,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(43,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(46,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(20,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(23,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(31,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(34,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(42,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(45,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts (6 errors) ==== - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js index ecd6e3c7dde..4f130505382 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js @@ -1,5 +1,4 @@ //// [contextuallyTypedClassExpressionMethodDeclaration02.ts] - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js index 373854114d5..ad84355595c 100644 --- a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js +++ b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js @@ -1,5 +1,4 @@ //// [contextuallyTypedObjectLiteralMethodDeclaration01.ts] - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols index c240af42b91..156eddefd93 100644 --- a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols +++ b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols @@ -1,110 +1,109 @@ === tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedObjectLiteralMethodDeclaration01.ts === - interface A { >A : Symbol(A, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 0)) numProp: number; ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) } interface B { ->B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 3, 1)) +>B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 2, 1)) strProp: string; ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } interface Foo { ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) method1(arg: A): void; ->method1 : Symbol(Foo.method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 9, 15)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 10, 12)) +>method1 : Symbol(Foo.method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 8, 15)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 9, 12)) >A : Symbol(A, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 0)) method2(arg: B): void; ->method2 : Symbol(Foo.method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 10, 26)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 11, 12)) ->B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 3, 1)) +>method2 : Symbol(Foo.method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 9, 26)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 10, 12)) +>B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 2, 1)) } function getFoo1(): Foo { ->getFoo1 : Symbol(getFoo1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 12, 1)) ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>getFoo1 : Symbol(getFoo1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 11, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) return { method1(arg) { ->method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 15, 12)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 16, 16)) +>method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 14, 12)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 15, 16)) arg.numProp = 10; ->arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 16, 16)) ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 15, 16)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) }, method2(arg) { ->method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 18, 10)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 19, 16)) +>method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 17, 10)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 18, 16)) arg.strProp = "hello"; ->arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 19, 16)) ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 18, 16)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } } } function getFoo2(): Foo { ->getFoo2 : Symbol(getFoo2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 23, 1)) ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>getFoo2 : Symbol(getFoo2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 22, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) return { method1: (arg) => { ->method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 26, 12)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 27, 18)) +>method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 25, 12)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 26, 18)) arg.numProp = 10; ->arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 27, 18)) ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 26, 18)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) }, method2: (arg) => { ->method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 29, 10)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 30, 18)) +>method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 28, 10)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 29, 18)) arg.strProp = "hello"; ->arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 30, 18)) ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 29, 18)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } } } function getFoo3(): Foo { ->getFoo3 : Symbol(getFoo3, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 34, 1)) ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>getFoo3 : Symbol(getFoo3, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 33, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) return { method1: function (arg) { ->method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 37, 12)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 38, 27)) +>method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 36, 12)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 37, 27)) arg.numProp = 10; ->arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 38, 27)) ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 37, 27)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) }, method2: function (arg) { ->method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 40, 10)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 41, 27)) +>method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 39, 10)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 40, 27)) arg.strProp = "hello"; ->arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 41, 27)) ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 40, 27)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } } } diff --git a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types index 5335cc4f81f..abf1a65158c 100644 --- a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types +++ b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedObjectLiteralMethodDeclaration01.ts === - interface A { >A : A diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt index 47d0b8c839a..4b74bb357ea 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(16,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(15,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. Types of property 'foo' are incompatible. Type '"f"' is not assignable to type '"A" | "B" | "C"'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(17,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(16,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. Types of property 'foo' are incompatible. Type '"f"' is not assignable to type '"A" | "B" | "C"'. ==== tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx (2 errors) ==== - namespace JSX { export interface IntrinsicElements { span: {}; diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js index d1b2ebf5ae5..7913e1ff5d0 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js @@ -1,5 +1,4 @@ //// [contextuallyTypedStringLiteralsInJsxAttributes01.tsx] - namespace JSX { export interface IntrinsicElements { span: {}; diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt index 0ef067e5bbc..28c550ccda1 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt @@ -1,19 +1,18 @@ -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(28,24): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(27,24): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(29,24): error TS2322: Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(28,24): error TS2322: Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'onClick' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(30,24): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(29,24): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(31,24): error TS2322: Type '{ goTo: "home"; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(30,24): error TS2322: Type '{ goTo: "home"; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(34,25): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(33,25): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(37,25): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,25): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. ==== tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx (6 errors) ==== - import React = require('react') export interface ClickableProps { diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js index 6f195cabebd..9eb261b9d7a 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react') export interface ClickableProps { diff --git a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt index dec899c7218..1c80f7057b8 100644 --- a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt +++ b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/continueNotInIterationStatement4.ts(5,5): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/continueNotInIterationStatement4.ts (1 errors) ==== - TWO: while (true){ var x = () => { diff --git a/tests/baselines/reference/continueNotInIterationStatement4.js b/tests/baselines/reference/continueNotInIterationStatement4.js index 50261be23b1..f3f52ecb48c 100644 --- a/tests/baselines/reference/continueNotInIterationStatement4.js +++ b/tests/baselines/reference/continueNotInIterationStatement4.js @@ -1,5 +1,4 @@ //// [continueNotInIterationStatement4.ts] - TWO: while (true){ var x = () => { diff --git a/tests/baselines/reference/continueTarget3.js b/tests/baselines/reference/continueTarget3.js index 70c2d2590e5..052b7b593c3 100644 --- a/tests/baselines/reference/continueTarget3.js +++ b/tests/baselines/reference/continueTarget3.js @@ -1,5 +1,4 @@ //// [continueTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/continueTarget3.symbols b/tests/baselines/reference/continueTarget3.symbols index a5decfe16d1..a1b930f2f5a 100644 --- a/tests/baselines/reference/continueTarget3.symbols +++ b/tests/baselines/reference/continueTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/continueTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target1; diff --git a/tests/baselines/reference/continueTarget3.types b/tests/baselines/reference/continueTarget3.types index 502c406b05f..5d45c50dc67 100644 --- a/tests/baselines/reference/continueTarget3.types +++ b/tests/baselines/reference/continueTarget3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/continueTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/continueTarget4.js b/tests/baselines/reference/continueTarget4.js index 23c20a03260..0f6211f9202 100644 --- a/tests/baselines/reference/continueTarget4.js +++ b/tests/baselines/reference/continueTarget4.js @@ -1,5 +1,4 @@ //// [continueTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/continueTarget4.symbols b/tests/baselines/reference/continueTarget4.symbols index fc69a881a60..ea1989a3e4d 100644 --- a/tests/baselines/reference/continueTarget4.symbols +++ b/tests/baselines/reference/continueTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/continueTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target2; diff --git a/tests/baselines/reference/continueTarget4.types b/tests/baselines/reference/continueTarget4.types index e07208ccc10..44160045532 100644 --- a/tests/baselines/reference/continueTarget4.types +++ b/tests/baselines/reference/continueTarget4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/continueTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/continueTarget5.errors.txt b/tests/baselines/reference/continueTarget5.errors.txt index 854f57017b6..401c5874ee0 100644 --- a/tests/baselines/reference/continueTarget5.errors.txt +++ b/tests/baselines/reference/continueTarget5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/continueTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/continueTarget5.ts (1 errors) ==== - target: while (true) { function f() { diff --git a/tests/baselines/reference/continueTarget5.js b/tests/baselines/reference/continueTarget5.js index 030a1c2589c..5bf309d2690 100644 --- a/tests/baselines/reference/continueTarget5.js +++ b/tests/baselines/reference/continueTarget5.js @@ -1,5 +1,4 @@ //// [continueTarget5.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/controlFlowArrayErrors.errors.txt b/tests/baselines/reference/controlFlowArrayErrors.errors.txt index 2ef009dc0e1..403cafacf5d 100644 --- a/tests/baselines/reference/controlFlowArrayErrors.errors.txt +++ b/tests/baselines/reference/controlFlowArrayErrors.errors.txt @@ -1,19 +1,18 @@ -tests/cases/compiler/controlFlowArrayErrors.ts(5,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(6,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. -tests/cases/compiler/controlFlowArrayErrors.ts(12,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(14,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. -tests/cases/compiler/controlFlowArrayErrors.ts(20,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(23,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. -tests/cases/compiler/controlFlowArrayErrors.ts(30,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. -tests/cases/compiler/controlFlowArrayErrors.ts(35,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. -tests/cases/compiler/controlFlowArrayErrors.ts(49,5): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '((...items: (string | number)[]) => number) | ((...items: boolean[]) => number)' has no compatible call signatures. -tests/cases/compiler/controlFlowArrayErrors.ts(57,12): error TS2345: Argument of type '"hello"' is not assignable to parameter of type 'number'. -tests/cases/compiler/controlFlowArrayErrors.ts(61,11): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(64,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(4,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(5,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(11,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(13,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(19,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(22,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(29,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. +tests/cases/compiler/controlFlowArrayErrors.ts(34,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. +tests/cases/compiler/controlFlowArrayErrors.ts(48,5): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '((...items: (string | number)[]) => number) | ((...items: boolean[]) => number)' has no compatible call signatures. +tests/cases/compiler/controlFlowArrayErrors.ts(56,12): error TS2345: Argument of type '"hello"' is not assignable to parameter of type 'number'. +tests/cases/compiler/controlFlowArrayErrors.ts(60,11): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(63,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. ==== tests/cases/compiler/controlFlowArrayErrors.ts (12 errors) ==== - declare function cond(): boolean; function f1() { diff --git a/tests/baselines/reference/controlFlowArrayErrors.js b/tests/baselines/reference/controlFlowArrayErrors.js index 59995eb3094..d1a76b80ebf 100644 --- a/tests/baselines/reference/controlFlowArrayErrors.js +++ b/tests/baselines/reference/controlFlowArrayErrors.js @@ -1,5 +1,4 @@ //// [controlFlowArrayErrors.ts] - declare function cond(): boolean; function f1() { diff --git a/tests/baselines/reference/controlFlowArrays.js b/tests/baselines/reference/controlFlowArrays.js index 3f119599495..134216b2eea 100644 --- a/tests/baselines/reference/controlFlowArrays.js +++ b/tests/baselines/reference/controlFlowArrays.js @@ -1,5 +1,4 @@ //// [controlFlowArrays.ts] - declare function cond(): boolean; function f1() { diff --git a/tests/baselines/reference/controlFlowArrays.symbols b/tests/baselines/reference/controlFlowArrays.symbols index 184a813a05f..ad6ee0e9f80 100644 --- a/tests/baselines/reference/controlFlowArrays.symbols +++ b/tests/baselines/reference/controlFlowArrays.symbols @@ -1,379 +1,378 @@ === tests/cases/compiler/controlFlowArrays.ts === - declare function cond(): boolean; >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(controlFlowArrays.ts, 1, 33)) +>f1 : Symbol(f1, Decl(controlFlowArrays.ts, 0, 33)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) x[0] = 5; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) x[1] = "hello"; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) x[2] = true; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) } function f2() { ->f2 : Symbol(f2, Decl(controlFlowArrays.ts, 9, 1)) +>f2 : Symbol(f2, Decl(controlFlowArrays.ts, 8, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) } function f3() { ->f3 : Symbol(f3, Decl(controlFlowArrays.ts, 17, 1)) +>f3 : Symbol(f3, Decl(controlFlowArrays.ts, 16, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) x.push(5, "hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) } function f4() { ->f4 : Symbol(f4, Decl(controlFlowArrays.ts, 24, 1)) +>f4 : Symbol(f4, Decl(controlFlowArrays.ts, 23, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } else { x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) } function f5() { ->f5 : Symbol(f5, Decl(controlFlowArrays.ts, 35, 1)) +>f5 : Symbol(f5, Decl(controlFlowArrays.ts, 34, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } else { x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) } function f6() { ->f6 : Symbol(f6, Decl(controlFlowArrays.ts, 48, 1)) +>f6 : Symbol(f6, Decl(controlFlowArrays.ts, 47, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x = 5; ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) } else { x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // number | string[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) } function f7() { ->f7 : Symbol(f7, Decl(controlFlowArrays.ts, 60, 1)) +>f7 : Symbol(f7, Decl(controlFlowArrays.ts, 59, 1)) let x = null; ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) while (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } } return x; // string[] | null ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) } function f8() { ->f8 : Symbol(f8, Decl(controlFlowArrays.ts, 71, 1)) +>f8 : Symbol(f8, Decl(controlFlowArrays.ts, 70, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) if (cond()) return x; // number[] >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) if (cond()) return x; // (string | number)[] >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) } function f9() { ->f9 : Symbol(f9, Decl(controlFlowArrays.ts, 81, 1)) +>f9 : Symbol(f9, Decl(controlFlowArrays.ts, 80, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // number[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) } else { x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // string[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) } } function f10() { ->f10 : Symbol(f10, Decl(controlFlowArrays.ts, 93, 1)) +>f10 : Symbol(f10, Decl(controlFlowArrays.ts, 92, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x; // boolean[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) } else { x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x; // number[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) while (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) } x.push(99); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) } function f11() { ->f11 : Symbol(f11, Decl(controlFlowArrays.ts, 111, 1)) +>f11 : Symbol(f11, Decl(controlFlowArrays.ts, 110, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) if (x.length === 0) { // x.length ok on implicit any[] >x.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) } function f12() { ->f12 : Symbol(f12, Decl(controlFlowArrays.ts, 119, 1)) +>f12 : Symbol(f12, Decl(controlFlowArrays.ts, 118, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) if (x.length === 0) { // x.length ok on implicit any[] >x.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) } function f13() { ->f13 : Symbol(f13, Decl(controlFlowArrays.ts, 128, 1)) +>f13 : Symbol(f13, Decl(controlFlowArrays.ts, 127, 1)) var x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) } function f14() { ->f14 : Symbol(f14, Decl(controlFlowArrays.ts, 136, 1)) +>f14 : Symbol(f14, Decl(controlFlowArrays.ts, 135, 1)) const x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) } function f15() { ->f15 : Symbol(f15, Decl(controlFlowArrays.ts, 144, 1)) +>f15 : Symbol(f15, Decl(controlFlowArrays.ts, 143, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 147, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 146, 7)) while (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) @@ -383,88 +382,88 @@ function f15() { x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 147, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 146, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // string[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 147, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 146, 7)) } function f16() { ->f16 : Symbol(f16, Decl(controlFlowArrays.ts, 153, 1)) +>f16 : Symbol(f16, Decl(controlFlowArrays.ts, 152, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) let y; ->y : Symbol(y, Decl(controlFlowArrays.ts, 157, 7)) +>y : Symbol(y, Decl(controlFlowArrays.ts, 156, 7)) (x = [], x).push(5); >(x = [], x).push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) (x.push("hello"), x).push(true); >(x.push("hello"), x).push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ((x))[3] = { a: 1 }; ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) ->a : Symbol(a, Decl(controlFlowArrays.ts, 160, 16)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) +>a : Symbol(a, Decl(controlFlowArrays.ts, 159, 16)) return x; // (string | number | boolean | { a: number })[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) } function f17() { ->f17 : Symbol(f17, Decl(controlFlowArrays.ts, 162, 1)) +>f17 : Symbol(f17, Decl(controlFlowArrays.ts, 161, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) x.unshift(5); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) x.unshift("hello"); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) x.unshift(true); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) } function f18() { ->f18 : Symbol(f18, Decl(controlFlowArrays.ts, 170, 1)) +>f18 : Symbol(f18, Decl(controlFlowArrays.ts, 169, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.unshift("hello"); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) x[2] = true; ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) } diff --git a/tests/baselines/reference/controlFlowArrays.types b/tests/baselines/reference/controlFlowArrays.types index 2a27bbf10de..6dbddbda075 100644 --- a/tests/baselines/reference/controlFlowArrays.types +++ b/tests/baselines/reference/controlFlowArrays.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowArrays.ts === - declare function cond(): boolean; >cond : () => boolean diff --git a/tests/baselines/reference/controlFlowCaching.js b/tests/baselines/reference/controlFlowCaching.js index fc102b8e823..c8b7cb5cc2c 100644 --- a/tests/baselines/reference/controlFlowCaching.js +++ b/tests/baselines/reference/controlFlowCaching.js @@ -1,5 +1,4 @@ //// [controlFlowCaching.ts] - // Repro for #8401 function f(dim, offsets, arr, acommon, centerAnchorLimit, g, has, lin) { diff --git a/tests/baselines/reference/controlFlowCaching.symbols b/tests/baselines/reference/controlFlowCaching.symbols index 74534ce75a1..186c770b0ae 100644 --- a/tests/baselines/reference/controlFlowCaching.symbols +++ b/tests/baselines/reference/controlFlowCaching.symbols @@ -1,279 +1,278 @@ === tests/cases/compiler/controlFlowCaching.ts === - // Repro for #8401 function f(dim, offsets, arr, acommon, centerAnchorLimit, g, has, lin) { >f : Symbol(f, Decl(controlFlowCaching.ts, 0, 0)) ->dim : Symbol(dim, Decl(controlFlowCaching.ts, 3, 11)) ->offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 3, 15)) ->arr : Symbol(arr, Decl(controlFlowCaching.ts, 3, 24)) ->acommon : Symbol(acommon, Decl(controlFlowCaching.ts, 3, 29)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->has : Symbol(has, Decl(controlFlowCaching.ts, 3, 60)) ->lin : Symbol(lin, Decl(controlFlowCaching.ts, 3, 65)) +>dim : Symbol(dim, Decl(controlFlowCaching.ts, 2, 11)) +>offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 2, 15)) +>arr : Symbol(arr, Decl(controlFlowCaching.ts, 2, 24)) +>acommon : Symbol(acommon, Decl(controlFlowCaching.ts, 2, 29)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>has : Symbol(has, Decl(controlFlowCaching.ts, 2, 60)) +>lin : Symbol(lin, Decl(controlFlowCaching.ts, 2, 65)) var isRtl = this._isRtl(); // chart mirroring ->isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 4, 7)) +>isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 3, 7)) // prepare variable var o = this.opt, ta = this.chart.theme.axis, position = o.position, ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->position : Symbol(position, Decl(controlFlowCaching.ts, 6, 49)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>position : Symbol(position, Decl(controlFlowCaching.ts, 5, 49)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) leftBottom = position !== "rightOrTop", rotation = o.rotation % 360, ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->position : Symbol(position, Decl(controlFlowCaching.ts, 6, 49)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>position : Symbol(position, Decl(controlFlowCaching.ts, 5, 49)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) start, stop, titlePos, titleRotation = 0, titleOffset, axisVector, tickVector, anchorOffset, labelOffset, labelAlign, ->start : Symbol(start, Decl(controlFlowCaching.ts, 7, 76)) ->stop : Symbol(stop, Decl(controlFlowCaching.ts, 8, 14)) ->titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 8, 20)) ->titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 8, 30)) ->titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 8, 49)) ->axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 8, 62)) ->tickVector : Symbol(tickVector, Decl(controlFlowCaching.ts, 8, 74)) ->anchorOffset : Symbol(anchorOffset, Decl(controlFlowCaching.ts, 8, 86)) ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>start : Symbol(start, Decl(controlFlowCaching.ts, 6, 76)) +>stop : Symbol(stop, Decl(controlFlowCaching.ts, 7, 14)) +>titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 7, 20)) +>titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 7, 30)) +>titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 7, 49)) +>axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 7, 62)) +>tickVector : Symbol(tickVector, Decl(controlFlowCaching.ts, 7, 74)) +>anchorOffset : Symbol(anchorOffset, Decl(controlFlowCaching.ts, 7, 86)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) labelGap = this.chart.theme.axis.tick.labelGap, ->labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 8, 125)) +>labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 7, 125)) taFont = o.font || (ta.majorTick && ta.majorTick.font) || (ta.tick && ta.tick.font), ->taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 9, 55)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 8, 55)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleFont = o.titleFont || (ta.title && ta.title.font), ->taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 10, 92)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 9, 92)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taFontColor = o.fontColor || (ta.majorTick && ta.majorTick.fontColor) || (ta.tick && ta.tick.fontColor) || "black", ->taFontColor : Symbol(taFontColor, Decl(controlFlowCaching.ts, 11, 65)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taFontColor : Symbol(taFontColor, Decl(controlFlowCaching.ts, 10, 65)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleFontColor = o.titleFontColor || (ta.title && ta.title.fontColor) || "black", ->taTitleFontColor : Symbol(taTitleFontColor, Decl(controlFlowCaching.ts, 12, 123)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleFontColor : Symbol(taTitleFontColor, Decl(controlFlowCaching.ts, 11, 123)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleGap = (o.titleGap == 0) ? 0 : o.titleGap || (ta.title && ta.title.gap) || 15, ->taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 13, 91)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 12, 91)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleOrientation = o.titleOrientation || (ta.title && ta.title.orientation) || "axis", ->taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 14, 92)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 13, 92)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taMajorTick = this.chart.theme.getTick("major", o), ->taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 15, 96)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 14, 96)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) taMinorTick = this.chart.theme.getTick("minor", o), ->taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 16, 59)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 15, 59)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) taMicroTick = this.chart.theme.getTick("micro", o), ->taMicroTick : Symbol(taMicroTick, Decl(controlFlowCaching.ts, 17, 59)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>taMicroTick : Symbol(taMicroTick, Decl(controlFlowCaching.ts, 16, 59)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) taStroke = "stroke" in o ? o.stroke : ta.stroke, ->taStroke : Symbol(taStroke, Decl(controlFlowCaching.ts, 18, 59)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taStroke : Symbol(taStroke, Decl(controlFlowCaching.ts, 17, 59)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0, ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) ->taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 9, 55)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 9, 55)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) +>taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 8, 55)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 8, 55)) cosr = Math.abs(Math.cos(rotation * Math.PI / 180)), ->cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 21, 79)) +>cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 20, 79)) >Math.abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math.cos : Symbol(Math.cos, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >cos : Symbol(Math.cos, Decl(lib.d.ts, --, --)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) sinr = Math.abs(Math.sin(rotation * Math.PI / 180)), ->sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 22, 60)) +>sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 21, 60)) >Math.abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) tsize = taTitleFont ? g.normalizedLength(g.splitFontString(taTitleFont).size) : 0; ->tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 23, 60)) ->taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 10, 92)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 10, 92)) +>tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 22, 60)) +>taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 9, 92)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 9, 92)) if (rotation < 0) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) rotation += 360; ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) } var cachedLabelW = this._getMaxLabelSize(); ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) cachedLabelW = cachedLabelW && cachedLabelW.majLabelW; ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) titleOffset = size * cosr + (cachedLabelW || 0) * sinr + labelGap + Math.max(taMajorTick.length > 0 ? taMajorTick.length : 0, ->titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 8, 49)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) ->cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 21, 79)) ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) ->sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 22, 60)) ->labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 8, 125)) +>titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 7, 49)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) +>cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 20, 79)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) +>sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 21, 60)) +>labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 7, 125)) >Math.max : Symbol(Math.max, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >max : Symbol(Math.max, Decl(lib.d.ts, --, --)) ->taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 15, 96)) ->taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 15, 96)) +>taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 14, 96)) +>taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 14, 96)) taMinorTick.length > 0 ? taMinorTick.length : 0) + ->taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 16, 59)) ->taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 16, 59)) +>taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 15, 59)) +>taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 15, 59)) tsize + taTitleGap; ->tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 23, 60)) ->taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 13, 91)) +>tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 22, 60)) +>taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 12, 91)) axisVector = { x: isRtl ? -1 : 1, y: 0 }; // chart mirroring ->axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 8, 62)) ->x : Symbol(x, Decl(controlFlowCaching.ts, 33, 18)) ->isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 4, 7)) ->y : Symbol(y, Decl(controlFlowCaching.ts, 33, 37)) +>axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 7, 62)) +>x : Symbol(x, Decl(controlFlowCaching.ts, 32, 18)) +>isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 3, 7)) +>y : Symbol(y, Decl(controlFlowCaching.ts, 32, 37)) switch (rotation) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) default: if (rotation < (90 - centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.y = leftBottom ? size : 0; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < (90 + centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.x = -size * 0.4; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < 180) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) labelOffset.y = leftBottom ? 0 : -size; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < (270 - centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.y = leftBottom ? 0 : -size; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < (270 + centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.y = leftBottom ? size * 0.4 : 0; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else { labelOffset.y = leftBottom ? size : 0; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } } titleRotation = (taTitleOrientation && taTitleOrientation == "away") ? 180 : 0; ->titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 8, 30)) ->taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 14, 92)) ->taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 14, 92)) +>titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 7, 30)) +>taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 13, 92)) +>taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 13, 92)) titlePos.y = offsets.t - titleOffset + (titleRotation ? 0 : tsize); ->titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 8, 20)) ->offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 3, 15)) ->titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 8, 49)) ->titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 8, 30)) ->tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 23, 60)) +>titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 7, 20)) +>offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 2, 15)) +>titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 7, 49)) +>titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 7, 30)) +>tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 22, 60)) switch (labelAlign) { ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) case "start": labelAlign = "end"; ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) break; case "end": labelAlign = "start"; ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) break; case "middle": labelOffset.y -= size; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) break; } let _ = rotation; ->_ : Symbol(_, Decl(controlFlowCaching.ts, 65, 7)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>_ : Symbol(_, Decl(controlFlowCaching.ts, 64, 7)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) } diff --git a/tests/baselines/reference/controlFlowCaching.types b/tests/baselines/reference/controlFlowCaching.types index 4b7df020c94..f78de65da5a 100644 --- a/tests/baselines/reference/controlFlowCaching.types +++ b/tests/baselines/reference/controlFlowCaching.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowCaching.ts === - // Repro for #8401 function f(dim, offsets, arr, acommon, centerAnchorLimit, g, has, lin) { diff --git a/tests/baselines/reference/controlFlowDeleteOperator.errors.txt b/tests/baselines/reference/controlFlowDeleteOperator.errors.txt index a8cf358a29a..757f3629975 100644 --- a/tests/baselines/reference/controlFlowDeleteOperator.errors.txt +++ b/tests/baselines/reference/controlFlowDeleteOperator.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/controlFlow/controlFlowDeleteOperator.ts(15,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/controlFlow/controlFlowDeleteOperator.ts(14,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/controlFlow/controlFlowDeleteOperator.ts (1 errors) ==== - function f() { let x: { a?: number | string, b: number | string } = { b: 1 }; x.a; diff --git a/tests/baselines/reference/controlFlowDeleteOperator.js b/tests/baselines/reference/controlFlowDeleteOperator.js index 36ac88467d2..71be5ca2de0 100644 --- a/tests/baselines/reference/controlFlowDeleteOperator.js +++ b/tests/baselines/reference/controlFlowDeleteOperator.js @@ -1,5 +1,4 @@ //// [controlFlowDeleteOperator.ts] - function f() { let x: { a?: number | string, b: number | string } = { b: 1 }; x.a; diff --git a/tests/baselines/reference/controlFlowDestructuringDeclaration.js b/tests/baselines/reference/controlFlowDestructuringDeclaration.js index 766fb6baeb2..39192f1baad 100644 --- a/tests/baselines/reference/controlFlowDestructuringDeclaration.js +++ b/tests/baselines/reference/controlFlowDestructuringDeclaration.js @@ -1,5 +1,4 @@ //// [controlFlowDestructuringDeclaration.ts] - function f1() { let x: string | number = 1; x; diff --git a/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols b/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols index 65f0e497942..ebdc2adfd1e 100644 --- a/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols +++ b/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols @@ -1,164 +1,163 @@ === tests/cases/conformance/controlFlow/controlFlowDestructuringDeclaration.ts === - function f1() { >f1 : Symbol(f1, Decl(controlFlowDestructuringDeclaration.ts, 0, 0)) let x: string | number = 1; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 2, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 1, 7)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 2, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 1, 7)) let y: string | undefined = ""; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 4, 7)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 3, 7)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 4, 7)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 3, 7)) } function f2() { ->f2 : Symbol(f2, Decl(controlFlowDestructuringDeclaration.ts, 6, 1)) +>f2 : Symbol(f2, Decl(controlFlowDestructuringDeclaration.ts, 5, 1)) let [x]: [string | number] = [1]; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 9, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 8, 9)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 9, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 8, 9)) let [y]: [string | undefined] = [""]; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 11, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 10, 9)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 11, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 10, 9)) let [z = ""]: [string | undefined] = [undefined]; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 13, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 12, 9)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 13, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 12, 9)) } function f3() { ->f3 : Symbol(f3, Decl(controlFlowDestructuringDeclaration.ts, 15, 1)) +>f3 : Symbol(f3, Decl(controlFlowDestructuringDeclaration.ts, 14, 1)) let [x]: (string | number)[] = [1]; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 18, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 17, 9)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 18, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 17, 9)) let [y]: (string | undefined)[] = [""]; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 20, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 19, 9)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 20, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 19, 9)) let [z = ""]: (string | undefined)[] = [undefined]; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 22, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 21, 9)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 22, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 21, 9)) } function f4() { ->f4 : Symbol(f4, Decl(controlFlowDestructuringDeclaration.ts, 24, 1)) +>f4 : Symbol(f4, Decl(controlFlowDestructuringDeclaration.ts, 23, 1)) let { x }: { x: string | number } = { x: 1 }; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 16)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 41)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 16)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 41)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 9)) let { y }: { y: string | undefined } = { y: "" }; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 9)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 16)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 44)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 16)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 44)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 9)) let { z = "" }: { z: string | undefined } = { z: undefined }; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 9)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 21)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 49)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 21)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 49)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 9)) } function f5() { ->f5 : Symbol(f5, Decl(controlFlowDestructuringDeclaration.ts, 33, 1)) +>f5 : Symbol(f5, Decl(controlFlowDestructuringDeclaration.ts, 32, 1)) let { x }: { x?: string | number } = { x: 1 }; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 16)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 42)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 16)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 42)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 9)) let { y }: { y?: string | undefined } = { y: "" }; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 9)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 16)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 45)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 16)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 45)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 9)) let { z = "" }: { z?: string | undefined } = { z: undefined }; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 9)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 21)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 50)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 21)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 50)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 9)) } function f6() { ->f6 : Symbol(f6, Decl(controlFlowDestructuringDeclaration.ts, 42, 1)) +>f6 : Symbol(f6, Decl(controlFlowDestructuringDeclaration.ts, 41, 1)) let { x }: { x?: string | number } = {}; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 45, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 45, 16)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 44, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 44, 16)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 45, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 44, 9)) let { y }: { y?: string | undefined } = {}; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 47, 9)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 47, 16)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 46, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 46, 16)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 47, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 46, 9)) let { z = "" }: { z?: string | undefined } = {}; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 49, 9)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 49, 21)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 48, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 48, 21)) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 49, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 48, 9)) } function f7() { ->f7 : Symbol(f7, Decl(controlFlowDestructuringDeclaration.ts, 51, 1)) +>f7 : Symbol(f7, Decl(controlFlowDestructuringDeclaration.ts, 50, 1)) let o: { [x: string]: number } = { x: 1 }; ->o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 54, 7)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 14)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 38)) +>o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 53, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 53, 14)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 53, 38)) let { x }: { [x: string]: string | number } = o; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 55, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 55, 18)) ->o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 54, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 18)) +>o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 53, 7)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 55, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 9)) } diff --git a/tests/baselines/reference/controlFlowDestructuringDeclaration.types b/tests/baselines/reference/controlFlowDestructuringDeclaration.types index d50b743b746..2815f2e1884 100644 --- a/tests/baselines/reference/controlFlowDestructuringDeclaration.types +++ b/tests/baselines/reference/controlFlowDestructuringDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowDestructuringDeclaration.ts === - function f1() { >f1 : () => void diff --git a/tests/baselines/reference/controlFlowIIFE.js b/tests/baselines/reference/controlFlowIIFE.js index 5d295b57315..20bde01cba6 100644 --- a/tests/baselines/reference/controlFlowIIFE.js +++ b/tests/baselines/reference/controlFlowIIFE.js @@ -1,5 +1,4 @@ //// [controlFlowIIFE.ts] - declare function getStringOrNumber(): string | number; function f1() { diff --git a/tests/baselines/reference/controlFlowIIFE.symbols b/tests/baselines/reference/controlFlowIIFE.symbols index b1b2b741158..4df906e0684 100644 --- a/tests/baselines/reference/controlFlowIIFE.symbols +++ b/tests/baselines/reference/controlFlowIIFE.symbols @@ -1,24 +1,23 @@ === tests/cases/conformance/controlFlow/controlFlowIIFE.ts === - declare function getStringOrNumber(): string | number; >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(controlFlowIIFE.ts, 1, 54)) +>f1 : Symbol(f1, Decl(controlFlowIIFE.ts, 0, 54)) let x = getStringOrNumber(); ->x : Symbol(x, Decl(controlFlowIIFE.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 3, 7)) >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) if (typeof x === "string") { ->x : Symbol(x, Decl(controlFlowIIFE.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 3, 7)) let n = function() { ->n : Symbol(n, Decl(controlFlowIIFE.ts, 6, 11)) +>n : Symbol(n, Decl(controlFlowIIFE.ts, 5, 11)) return x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIIFE.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 3, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }(); @@ -26,21 +25,21 @@ function f1() { } function f2() { ->f2 : Symbol(f2, Decl(controlFlowIIFE.ts, 10, 1)) +>f2 : Symbol(f2, Decl(controlFlowIIFE.ts, 9, 1)) let x = getStringOrNumber(); ->x : Symbol(x, Decl(controlFlowIIFE.ts, 13, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 12, 7)) >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) if (typeof x === "string") { ->x : Symbol(x, Decl(controlFlowIIFE.ts, 13, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 12, 7)) let n = (function() { ->n : Symbol(n, Decl(controlFlowIIFE.ts, 15, 11)) +>n : Symbol(n, Decl(controlFlowIIFE.ts, 14, 11)) return x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIIFE.ts, 13, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 12, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) })(); @@ -48,56 +47,56 @@ function f2() { } function f3() { ->f3 : Symbol(f3, Decl(controlFlowIIFE.ts, 19, 1)) +>f3 : Symbol(f3, Decl(controlFlowIIFE.ts, 18, 1)) let x = getStringOrNumber(); ->x : Symbol(x, Decl(controlFlowIIFE.ts, 22, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 21, 7)) >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) let y: number; ->y : Symbol(y, Decl(controlFlowIIFE.ts, 23, 7)) +>y : Symbol(y, Decl(controlFlowIIFE.ts, 22, 7)) if (typeof x === "string") { ->x : Symbol(x, Decl(controlFlowIIFE.ts, 22, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 21, 7)) let n = (z => x.length + y + z)(y = 1); ->n : Symbol(n, Decl(controlFlowIIFE.ts, 25, 11)) ->z : Symbol(z, Decl(controlFlowIIFE.ts, 25, 17)) +>n : Symbol(n, Decl(controlFlowIIFE.ts, 24, 11)) +>z : Symbol(z, Decl(controlFlowIIFE.ts, 24, 17)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIIFE.ts, 22, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 21, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(controlFlowIIFE.ts, 23, 7)) ->z : Symbol(z, Decl(controlFlowIIFE.ts, 25, 17)) ->y : Symbol(y, Decl(controlFlowIIFE.ts, 23, 7)) +>y : Symbol(y, Decl(controlFlowIIFE.ts, 22, 7)) +>z : Symbol(z, Decl(controlFlowIIFE.ts, 24, 17)) +>y : Symbol(y, Decl(controlFlowIIFE.ts, 22, 7)) } } // Repros from #8381 let maybeNumber: number | undefined; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) (function () { maybeNumber = 1; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) })(); maybeNumber++; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) if (maybeNumber !== undefined) { ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) >undefined : Symbol(undefined) maybeNumber++; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) } let test: string | undefined; ->test : Symbol(test, Decl(controlFlowIIFE.ts, 40, 3)) +>test : Symbol(test, Decl(controlFlowIIFE.ts, 39, 3)) if (!test) { ->test : Symbol(test, Decl(controlFlowIIFE.ts, 40, 3)) +>test : Symbol(test, Decl(controlFlowIIFE.ts, 39, 3)) throw new Error('Test is not defined'); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) @@ -105,7 +104,7 @@ if (!test) { (() => { test.slice(1); // No error >test.slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) ->test : Symbol(test, Decl(controlFlowIIFE.ts, 40, 3)) +>test : Symbol(test, Decl(controlFlowIIFE.ts, 39, 3)) >slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) })(); diff --git a/tests/baselines/reference/controlFlowIIFE.types b/tests/baselines/reference/controlFlowIIFE.types index 1c2e8290394..1132649ae09 100644 --- a/tests/baselines/reference/controlFlowIIFE.types +++ b/tests/baselines/reference/controlFlowIIFE.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowIIFE.ts === - declare function getStringOrNumber(): string | number; >getStringOrNumber : () => string | number diff --git a/tests/baselines/reference/controlFlowIfStatement.js b/tests/baselines/reference/controlFlowIfStatement.js index 5b09b13e5fd..e40b831552f 100644 --- a/tests/baselines/reference/controlFlowIfStatement.js +++ b/tests/baselines/reference/controlFlowIfStatement.js @@ -1,5 +1,4 @@ //// [controlFlowIfStatement.ts] - let x: string | number | boolean | RegExp; let cond: boolean; diff --git a/tests/baselines/reference/controlFlowIfStatement.symbols b/tests/baselines/reference/controlFlowIfStatement.symbols index 29d235de780..e4d2bb9f184 100644 --- a/tests/baselines/reference/controlFlowIfStatement.symbols +++ b/tests/baselines/reference/controlFlowIfStatement.symbols @@ -1,113 +1,112 @@ === tests/cases/conformance/controlFlow/controlFlowIfStatement.ts === - let x: string | number | boolean | RegExp; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) let cond: boolean; ->cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 2, 3)) +>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3)) x = /a/; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) if (x /* RegExp */, (x = true)) { ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) x; // boolean ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) x = ""; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) } else { x; // boolean ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) x = 42; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) } x; // string | number ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) function a() { ->a : Symbol(a, Decl(controlFlowIfStatement.ts, 13, 2)) +>a : Symbol(a, Decl(controlFlowIfStatement.ts, 12, 2)) let x: string | number; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 2, 3)) +>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3)) x = 42; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) } else { x = ""; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) return; } x; // number ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) } function b() { ->b : Symbol(b, Decl(controlFlowIfStatement.ts, 25, 1)) +>b : Symbol(b, Decl(controlFlowIfStatement.ts, 24, 1)) let x: string | number; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 2, 3)) +>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3)) x = 42; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) throw ""; } else { x = ""; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) } x; // string ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) } function c(data: string | T): T { ->c : Symbol(c, Decl(controlFlowIfStatement.ts, 36, 1)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 37, 11)) ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 37, 11)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 37, 11)) +>c : Symbol(c, Decl(controlFlowIfStatement.ts, 35, 1)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11)) if (typeof data === 'string') { ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) return JSON.parse(data); >JSON.parse : Symbol(JSON.parse, Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >parse : Symbol(JSON.parse, Decl(lib.d.ts, --, --)) ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) } else { return data; ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) } } function d(data: string | T): never { ->d : Symbol(d, Decl(controlFlowIfStatement.ts, 44, 1)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 45, 11)) ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 45, 29)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 45, 11)) +>d : Symbol(d, Decl(controlFlowIfStatement.ts, 43, 1)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 44, 11)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 44, 11)) if (typeof data === 'string') { ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 45, 29)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29)) throw new Error('will always happen'); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } else { return data; ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 45, 29)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29)) } } diff --git a/tests/baselines/reference/controlFlowIfStatement.types b/tests/baselines/reference/controlFlowIfStatement.types index e0ce68db7b1..7c745735c9e 100644 --- a/tests/baselines/reference/controlFlowIfStatement.types +++ b/tests/baselines/reference/controlFlowIfStatement.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowIfStatement.ts === - let x: string | number | boolean | RegExp; >x : string | number | boolean | RegExp >RegExp : RegExp diff --git a/tests/baselines/reference/controlFlowInstanceof.js b/tests/baselines/reference/controlFlowInstanceof.js index 3f2287b4628..89a8a7a3ddf 100644 --- a/tests/baselines/reference/controlFlowInstanceof.js +++ b/tests/baselines/reference/controlFlowInstanceof.js @@ -1,5 +1,4 @@ //// [controlFlowInstanceof.ts] - // Repros from #10167 function f1(s: Set | Set) { diff --git a/tests/baselines/reference/controlFlowInstanceof.symbols b/tests/baselines/reference/controlFlowInstanceof.symbols index 19304ada888..299bacbb8fe 100644 --- a/tests/baselines/reference/controlFlowInstanceof.symbols +++ b/tests/baselines/reference/controlFlowInstanceof.symbols @@ -1,232 +1,231 @@ === tests/cases/compiler/controlFlowInstanceof.ts === - // Repros from #10167 function f1(s: Set | Set) { >f1 : Symbol(f1, Decl(controlFlowInstanceof.ts, 0, 0)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s = new Set(); ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) if (s instanceof Set) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) } s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) s.add(42); >s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) } function f2(s: Set | Set) { ->f2 : Symbol(f2, Decl(controlFlowInstanceof.ts, 11, 1)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>f2 : Symbol(f2, Decl(controlFlowInstanceof.ts, 10, 1)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s = new Set(); ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) if (s instanceof Promise) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) s; // Set & Promise ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) } s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) s.add(42); >s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) } function f3(s: Set | Set) { ->f3 : Symbol(f3, Decl(controlFlowInstanceof.ts, 21, 1)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>f3 : Symbol(f3, Decl(controlFlowInstanceof.ts, 20, 1)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set | Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) if (s instanceof Set) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set | Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) } else { s; // never ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) } } function f4(s: Set | Set) { ->f4 : Symbol(f4, Decl(controlFlowInstanceof.ts, 31, 1)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>f4 : Symbol(f4, Decl(controlFlowInstanceof.ts, 30, 1)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s = new Set(); ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) if (s instanceof Set) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) } else { s; // never ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) } } // More tests class A { a: string } ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) ->a : Symbol(A.a, Decl(controlFlowInstanceof.ts, 46, 9)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) +>a : Symbol(A.a, Decl(controlFlowInstanceof.ts, 45, 9)) class B extends A { b: string } ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) ->b : Symbol(B.b, Decl(controlFlowInstanceof.ts, 47, 19)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) +>b : Symbol(B.b, Decl(controlFlowInstanceof.ts, 46, 19)) class C extends A { c: string } ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) ->c : Symbol(C.c, Decl(controlFlowInstanceof.ts, 48, 19)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) +>c : Symbol(C.c, Decl(controlFlowInstanceof.ts, 47, 19)) function foo(x: A | undefined) { ->foo : Symbol(foo, Decl(controlFlowInstanceof.ts, 48, 31)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) +>foo : Symbol(foo, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) x; // A | undefined ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof B || x instanceof C) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) x; // B | C ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // A | undefined ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof B && x instanceof C) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) x; // B & C ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // A | undefined ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (!x) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) return; } x; // A ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof B) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) x; // B ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof C) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) x; // B & C ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } else { x; // B ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // B ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } else { x; // A ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // A ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } // X is neither assignable to Y nor a subtype of Y // Y is assignable to X, but not a subtype of X interface X { ->X : Symbol(X, Decl(controlFlowInstanceof.ts, 78, 1)) +>X : Symbol(X, Decl(controlFlowInstanceof.ts, 77, 1)) x?: string; ->x : Symbol(X.x, Decl(controlFlowInstanceof.ts, 83, 13)) +>x : Symbol(X.x, Decl(controlFlowInstanceof.ts, 82, 13)) } class Y { ->Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 85, 1)) +>Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 84, 1)) y: string; ->y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9)) +>y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 86, 9)) } function goo(x: X) { ->goo : Symbol(goo, Decl(controlFlowInstanceof.ts, 89, 1)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) ->X : Symbol(X, Decl(controlFlowInstanceof.ts, 78, 1)) +>goo : Symbol(goo, Decl(controlFlowInstanceof.ts, 88, 1)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) +>X : Symbol(X, Decl(controlFlowInstanceof.ts, 77, 1)) x; ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) if (x instanceof Y) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) ->Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 85, 1)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) +>Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 84, 1)) x.y; ->x.y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) ->y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9)) +>x.y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 86, 9)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) +>y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 86, 9)) } x; ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) } diff --git a/tests/baselines/reference/controlFlowInstanceof.types b/tests/baselines/reference/controlFlowInstanceof.types index 3dc9fff8b04..16d1ec71462 100644 --- a/tests/baselines/reference/controlFlowInstanceof.types +++ b/tests/baselines/reference/controlFlowInstanceof.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowInstanceof.ts === - // Repros from #10167 function f1(s: Set | Set) { diff --git a/tests/baselines/reference/controlFlowIteration.js b/tests/baselines/reference/controlFlowIteration.js index 7b319ba8098..775d9f24083 100644 --- a/tests/baselines/reference/controlFlowIteration.js +++ b/tests/baselines/reference/controlFlowIteration.js @@ -1,5 +1,4 @@ //// [controlFlowIteration.ts] - let cond: boolean; function ff() { diff --git a/tests/baselines/reference/controlFlowIteration.symbols b/tests/baselines/reference/controlFlowIteration.symbols index 84c1c57b69b..1bd53194dcc 100644 --- a/tests/baselines/reference/controlFlowIteration.symbols +++ b/tests/baselines/reference/controlFlowIteration.symbols @@ -1,36 +1,35 @@ === tests/cases/conformance/controlFlow/controlFlowIteration.ts === - let cond: boolean; ->cond : Symbol(cond, Decl(controlFlowIteration.ts, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowIteration.ts, 0, 3)) function ff() { ->ff : Symbol(ff, Decl(controlFlowIteration.ts, 1, 18)) +>ff : Symbol(ff, Decl(controlFlowIteration.ts, 0, 18)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) while (true) { if (cond) { ->cond : Symbol(cond, Decl(controlFlowIteration.ts, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowIteration.ts, 0, 3)) x = ""; ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) } else { if (x) { ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } if (x) { ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/controlFlowIteration.types b/tests/baselines/reference/controlFlowIteration.types index a8c05b9732f..652dfc0c7cd 100644 --- a/tests/baselines/reference/controlFlowIteration.types +++ b/tests/baselines/reference/controlFlowIteration.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowIteration.ts === - let cond: boolean; >cond : boolean diff --git a/tests/baselines/reference/controlFlowIterationErrors.errors.txt b/tests/baselines/reference/controlFlowIterationErrors.errors.txt index 1f090ccd35f..081a372e271 100644 --- a/tests/baselines/reference/controlFlowIterationErrors.errors.txt +++ b/tests/baselines/reference/controlFlowIterationErrors.errors.txt @@ -1,21 +1,20 @@ -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(12,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(11,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(23,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(22,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(35,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(34,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(46,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(45,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(77,13): error TS7022: 'y' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(77,26): error TS2345: Argument of type 'string | number | boolean' is not assignable to parameter of type 'string | number'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(76,13): error TS7022: 'y' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(76,26): error TS2345: Argument of type 'string | number | boolean' is not assignable to parameter of type 'string | number'. Type 'true' is not assignable to type 'string | number'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(88,13): error TS7022: 'y' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(88,26): error TS2345: Argument of type 'string | number | boolean' is not assignable to parameter of type 'string | number'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(87,13): error TS7022: 'y' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(87,26): error TS2345: Argument of type 'string | number | boolean' is not assignable to parameter of type 'string | number'. Type 'true' is not assignable to type 'string | number'. ==== tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts (8 errors) ==== - let cond: boolean; function len(s: string) { diff --git a/tests/baselines/reference/controlFlowIterationErrors.js b/tests/baselines/reference/controlFlowIterationErrors.js index eed54cc53a7..50401631089 100644 --- a/tests/baselines/reference/controlFlowIterationErrors.js +++ b/tests/baselines/reference/controlFlowIterationErrors.js @@ -1,5 +1,4 @@ //// [controlFlowIterationErrors.ts] - let cond: boolean; function len(s: string) { diff --git a/tests/baselines/reference/controlFlowJavascript.js b/tests/baselines/reference/controlFlowJavascript.js index 66518a6567a..c119d5da623 100644 --- a/tests/baselines/reference/controlFlowJavascript.js +++ b/tests/baselines/reference/controlFlowJavascript.js @@ -1,5 +1,4 @@ //// [controlFlowJavascript.js] - let cond = true; // CFA for 'let' and no initializer diff --git a/tests/baselines/reference/controlFlowJavascript.symbols b/tests/baselines/reference/controlFlowJavascript.symbols index b3316de3b4e..6d35ec7481f 100644 --- a/tests/baselines/reference/controlFlowJavascript.symbols +++ b/tests/baselines/reference/controlFlowJavascript.symbols @@ -1,215 +1,214 @@ === tests/cases/compiler/controlFlowJavascript.js === - let cond = true; ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) // CFA for 'let' and no initializer function f1() { ->f1 : Symbol(f1, Decl(controlFlowJavascript.js, 1, 16)) +>f1 : Symbol(f1, Decl(controlFlowJavascript.js, 0, 16)) let x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 12, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 11, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) } // CFA for 'let' and 'undefined' initializer function f2() { ->f2 : Symbol(f2, Decl(controlFlowJavascript.js, 13, 1)) +>f2 : Symbol(f2, Decl(controlFlowJavascript.js, 12, 1)) let x = undefined; ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) >undefined : Symbol(undefined) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 24, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 23, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) } // CFA for 'let' and 'null' initializer function f3() { ->f3 : Symbol(f3, Decl(controlFlowJavascript.js, 25, 1)) +>f3 : Symbol(f3, Decl(controlFlowJavascript.js, 24, 1)) let x = null; ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) } const y = x; // string | number | null ->y : Symbol(y, Decl(controlFlowJavascript.js, 36, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 35, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) } // CFA for 'var' with no initializer function f5() { ->f5 : Symbol(f5, Decl(controlFlowJavascript.js, 37, 1)) +>f5 : Symbol(f5, Decl(controlFlowJavascript.js, 36, 1)) var x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 48, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 47, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) } // CFA for 'var' with 'undefined' initializer function f6() { ->f6 : Symbol(f6, Decl(controlFlowJavascript.js, 49, 1)) +>f6 : Symbol(f6, Decl(controlFlowJavascript.js, 48, 1)) var x = undefined; ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) >undefined : Symbol(undefined) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 60, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 59, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) } // CFA for 'var' with 'null' initializer function f7() { ->f7 : Symbol(f7, Decl(controlFlowJavascript.js, 61, 1)) +>f7 : Symbol(f7, Decl(controlFlowJavascript.js, 60, 1)) var x = null; ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) } const y = x; // string | number | null ->y : Symbol(y, Decl(controlFlowJavascript.js, 72, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 71, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) } // No CFA for captured outer variables function f9() { ->f9 : Symbol(f9, Decl(controlFlowJavascript.js, 73, 1)) +>f9 : Symbol(f9, Decl(controlFlowJavascript.js, 72, 1)) let x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 84, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 83, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) function f() { ->f : Symbol(f, Decl(controlFlowJavascript.js, 84, 16)) +>f : Symbol(f, Decl(controlFlowJavascript.js, 83, 16)) const z = x; // any ->z : Symbol(z, Decl(controlFlowJavascript.js, 86, 13)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>z : Symbol(z, Decl(controlFlowJavascript.js, 85, 13)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) } } // No CFA for captured outer variables function f10() { ->f10 : Symbol(f10, Decl(controlFlowJavascript.js, 88, 1)) +>f10 : Symbol(f10, Decl(controlFlowJavascript.js, 87, 1)) let x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 99, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 98, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) const f = () => { ->f : Symbol(f, Decl(controlFlowJavascript.js, 100, 9)) +>f : Symbol(f, Decl(controlFlowJavascript.js, 99, 9)) const z = x; // any ->z : Symbol(z, Decl(controlFlowJavascript.js, 101, 13)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>z : Symbol(z, Decl(controlFlowJavascript.js, 100, 13)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) }; } diff --git a/tests/baselines/reference/controlFlowJavascript.types b/tests/baselines/reference/controlFlowJavascript.types index 0b88c62cb78..2ac8c19bf1b 100644 --- a/tests/baselines/reference/controlFlowJavascript.types +++ b/tests/baselines/reference/controlFlowJavascript.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowJavascript.js === - let cond = true; >cond : boolean >true : true diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt b/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt index 0d08f93a8a8..68266dde43e 100644 --- a/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt +++ b/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/controlFlowLoopAnalysis.ts(13,25): error TS2345: Argument of type 'number | undefined' is not assignable to parameter of type 'number'. +tests/cases/compiler/controlFlowLoopAnalysis.ts(12,25): error TS2345: Argument of type 'number | undefined' is not assignable to parameter of type 'number'. Type 'undefined' is not assignable to type 'number'. ==== tests/cases/compiler/controlFlowLoopAnalysis.ts (1 errors) ==== - // Repro from #8418 let cond: boolean; diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.js b/tests/baselines/reference/controlFlowLoopAnalysis.js index 77384ddedcf..fa8dc29e92a 100644 --- a/tests/baselines/reference/controlFlowLoopAnalysis.js +++ b/tests/baselines/reference/controlFlowLoopAnalysis.js @@ -1,5 +1,4 @@ //// [controlFlowLoopAnalysis.ts] - // Repro from #8418 let cond: boolean; diff --git a/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt b/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt index d081f29d511..3684fc1b51b 100644 --- a/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt +++ b/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/controlFlowNoImplicitAny.ts(102,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowNoImplicitAny.ts(111,19): error TS7005: Variable 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowNoImplicitAny.ts(117,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowNoImplicitAny.ts(126,19): error TS7005: Variable 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowNoImplicitAny.ts(101,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowNoImplicitAny.ts(110,19): error TS7005: Variable 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowNoImplicitAny.ts(116,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowNoImplicitAny.ts(125,19): error TS7005: Variable 'x' implicitly has an 'any' type. ==== tests/cases/compiler/controlFlowNoImplicitAny.ts (4 errors) ==== - declare let cond: boolean; // CFA for 'let' with no type annotation and initializer diff --git a/tests/baselines/reference/controlFlowNoImplicitAny.js b/tests/baselines/reference/controlFlowNoImplicitAny.js index 9a5f302d87a..1b0cb41b7e2 100644 --- a/tests/baselines/reference/controlFlowNoImplicitAny.js +++ b/tests/baselines/reference/controlFlowNoImplicitAny.js @@ -1,5 +1,4 @@ //// [controlFlowNoImplicitAny.ts] - declare let cond: boolean; // CFA for 'let' with no type annotation and initializer diff --git a/tests/baselines/reference/controlFlowOuterVariable.js b/tests/baselines/reference/controlFlowOuterVariable.js index 1925d75eb31..55b83640cd9 100644 --- a/tests/baselines/reference/controlFlowOuterVariable.js +++ b/tests/baselines/reference/controlFlowOuterVariable.js @@ -1,5 +1,4 @@ //// [controlFlowOuterVariable.ts] - // Repros from #10641 const CONFIG = { diff --git a/tests/baselines/reference/controlFlowOuterVariable.symbols b/tests/baselines/reference/controlFlowOuterVariable.symbols index 35974f28a86..590878752f5 100644 --- a/tests/baselines/reference/controlFlowOuterVariable.symbols +++ b/tests/baselines/reference/controlFlowOuterVariable.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/controlFlowOuterVariable.ts === - // Repros from #10641 const CONFIG = { ->CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 3, 5)) +>CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 2, 5)) foo: '', ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 3, 16)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 2, 16)) setFoo: function(foo: string) { ->setFoo : Symbol(setFoo, Decl(controlFlowOuterVariable.ts, 4, 12)) ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 5, 21)) +>setFoo : Symbol(setFoo, Decl(controlFlowOuterVariable.ts, 3, 12)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 4, 21)) CONFIG.foo = foo; ->CONFIG.foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 3, 16)) ->CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 3, 5)) ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 3, 16)) ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 5, 21)) +>CONFIG.foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 2, 16)) +>CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 2, 5)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 2, 16)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 4, 21)) } }; const helper = function(t: T[]) { ->helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 10, 5)) ->T : Symbol(T, Decl(controlFlowOuterVariable.ts, 10, 24)) ->t : Symbol(t, Decl(controlFlowOuterVariable.ts, 10, 27)) ->T : Symbol(T, Decl(controlFlowOuterVariable.ts, 10, 24)) +>helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 9, 5)) +>T : Symbol(T, Decl(controlFlowOuterVariable.ts, 9, 24)) +>t : Symbol(t, Decl(controlFlowOuterVariable.ts, 9, 27)) +>T : Symbol(T, Decl(controlFlowOuterVariable.ts, 9, 24)) helper(t.slice(1)); ->helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 10, 5)) +>helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 9, 5)) >t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) ->t : Symbol(t, Decl(controlFlowOuterVariable.ts, 10, 27)) +>t : Symbol(t, Decl(controlFlowOuterVariable.ts, 9, 27)) >slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/controlFlowOuterVariable.types b/tests/baselines/reference/controlFlowOuterVariable.types index 859542e70e1..10d46d10bfc 100644 --- a/tests/baselines/reference/controlFlowOuterVariable.types +++ b/tests/baselines/reference/controlFlowOuterVariable.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowOuterVariable.ts === - // Repros from #10641 const CONFIG = { diff --git a/tests/baselines/reference/controlFlowPropertyInitializer.js b/tests/baselines/reference/controlFlowPropertyInitializer.js index 5d8e10651fa..dda9a2690bc 100644 --- a/tests/baselines/reference/controlFlowPropertyInitializer.js +++ b/tests/baselines/reference/controlFlowPropertyInitializer.js @@ -1,5 +1,4 @@ //// [controlFlowPropertyInitializer.ts] - // Repro from #8967 const LANG = "Turbo Pascal" diff --git a/tests/baselines/reference/controlFlowPropertyInitializer.symbols b/tests/baselines/reference/controlFlowPropertyInitializer.symbols index 70e6c2da8a1..be8ae00a905 100644 --- a/tests/baselines/reference/controlFlowPropertyInitializer.symbols +++ b/tests/baselines/reference/controlFlowPropertyInitializer.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/controlFlowPropertyInitializer.ts === - // Repro from #8967 const LANG = "Turbo Pascal" ->LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 3, 5)) +>LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 2, 5)) class BestLanguage { ->BestLanguage : Symbol(BestLanguage, Decl(controlFlowPropertyInitializer.ts, 3, 27)) +>BestLanguage : Symbol(BestLanguage, Decl(controlFlowPropertyInitializer.ts, 2, 27)) name = LANG; ->name : Symbol(BestLanguage.name, Decl(controlFlowPropertyInitializer.ts, 5, 20)) ->LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 3, 5)) +>name : Symbol(BestLanguage.name, Decl(controlFlowPropertyInitializer.ts, 4, 20)) +>LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 2, 5)) } diff --git a/tests/baselines/reference/controlFlowPropertyInitializer.types b/tests/baselines/reference/controlFlowPropertyInitializer.types index 7da8fefe958..ff3d757287b 100644 --- a/tests/baselines/reference/controlFlowPropertyInitializer.types +++ b/tests/baselines/reference/controlFlowPropertyInitializer.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowPropertyInitializer.ts === - // Repro from #8967 const LANG = "Turbo Pascal" diff --git a/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt b/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt index deef6403761..69f670359af 100644 --- a/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt +++ b/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt @@ -1,35 +1,34 @@ -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. ==== tests/cases/compiler/controlFlowSelfReferentialLoop.ts (28 errors) ==== - // Repro from #12319 function md5(string:string): void { diff --git a/tests/baselines/reference/controlFlowSelfReferentialLoop.js b/tests/baselines/reference/controlFlowSelfReferentialLoop.js index 0a7eff198ff..6d07f1dbca1 100644 --- a/tests/baselines/reference/controlFlowSelfReferentialLoop.js +++ b/tests/baselines/reference/controlFlowSelfReferentialLoop.js @@ -1,5 +1,4 @@ //// [controlFlowSelfReferentialLoop.ts] - // Repro from #12319 function md5(string:string): void { diff --git a/tests/baselines/reference/controlFlowTruthiness.js b/tests/baselines/reference/controlFlowTruthiness.js index b595bcbd180..b57befbd641 100644 --- a/tests/baselines/reference/controlFlowTruthiness.js +++ b/tests/baselines/reference/controlFlowTruthiness.js @@ -1,5 +1,4 @@ //// [controlFlowTruthiness.ts] - declare function foo(): string | undefined; function f1() { diff --git a/tests/baselines/reference/controlFlowTruthiness.symbols b/tests/baselines/reference/controlFlowTruthiness.symbols index 37c1fb135f2..72dd304f810 100644 --- a/tests/baselines/reference/controlFlowTruthiness.symbols +++ b/tests/baselines/reference/controlFlowTruthiness.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/controlFlow/controlFlowTruthiness.ts === - declare function foo(): string | undefined; >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(controlFlowTruthiness.ts, 1, 43)) +>f1 : Symbol(f1, Decl(controlFlowTruthiness.ts, 0, 43)) let x = foo(); ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) if (x) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) } } function f2() { ->f2 : Symbol(f2, Decl(controlFlowTruthiness.ts, 11, 1)) +>f2 : Symbol(f2, Decl(controlFlowTruthiness.ts, 10, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) x = foo(); ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) if (x) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) } } function f3() { ->f3 : Symbol(f3, Decl(controlFlowTruthiness.ts, 22, 1)) +>f3 : Symbol(f3, Decl(controlFlowTruthiness.ts, 21, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) if (x = foo()) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) } } function f4() { ->f4 : Symbol(f4, Decl(controlFlowTruthiness.ts, 32, 1)) +>f4 : Symbol(f4, Decl(controlFlowTruthiness.ts, 31, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) if (!(x = foo())) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) } else { x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) } } function f5() { ->f5 : Symbol(f5, Decl(controlFlowTruthiness.ts, 42, 1)) +>f5 : Symbol(f5, Decl(controlFlowTruthiness.ts, 41, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) let y: string | undefined; ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) if (x = y = foo()) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) y; // string | undefined ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) y; // string | undefined ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) } } function f6() { ->f6 : Symbol(f6, Decl(controlFlowTruthiness.ts, 55, 1)) +>f6 : Symbol(f6, Decl(controlFlowTruthiness.ts, 54, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) let y: string | undefined; ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) if (x = foo(), y = foo()) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) y; // string ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) y; // string | undefined ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) } } diff --git a/tests/baselines/reference/controlFlowTruthiness.types b/tests/baselines/reference/controlFlowTruthiness.types index 2d35856fe83..225f6d0e7e2 100644 --- a/tests/baselines/reference/controlFlowTruthiness.types +++ b/tests/baselines/reference/controlFlowTruthiness.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowTruthiness.ts === - declare function foo(): string | undefined; >foo : () => string | undefined diff --git a/tests/baselines/reference/declFileAccessors.js b/tests/baselines/reference/declFileAccessors.js index 64a99bb8438..a6e47b935c3 100644 --- a/tests/baselines/reference/declFileAccessors.js +++ b/tests/baselines/reference/declFileAccessors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileAccessors.ts] //// //// [declFileAccessors_0.ts] - /** This is comment for c1*/ export class c1 { /** getter property*/ diff --git a/tests/baselines/reference/declFileAccessors.symbols b/tests/baselines/reference/declFileAccessors.symbols index 3de90051ec4..e43f19c1e8c 100644 --- a/tests/baselines/reference/declFileAccessors.symbols +++ b/tests/baselines/reference/declFileAccessors.symbols @@ -1,81 +1,80 @@ === tests/cases/compiler/declFileAccessors_0.ts === - /** This is comment for c1*/ export class c1 { >c1 : Symbol(c1, Decl(declFileAccessors_0.ts, 0, 0)) /** getter property*/ public get p3() { ->p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 2, 17), Decl(declFileAccessors_0.ts, 6, 5)) +>p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 1, 17), Decl(declFileAccessors_0.ts, 5, 5)) return 10; } /** setter property*/ public set p3(/** this is value*/value: number) { ->p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 2, 17), Decl(declFileAccessors_0.ts, 6, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 8, 18)) +>p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 1, 17), Decl(declFileAccessors_0.ts, 5, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 7, 18)) } /** private getter property*/ private get pp3() { ->pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 9, 5), Decl(declFileAccessors_0.ts, 13, 5)) +>pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 8, 5), Decl(declFileAccessors_0.ts, 12, 5)) return 10; } /** private setter property*/ private set pp3(/** this is value*/value: number) { ->pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 9, 5), Decl(declFileAccessors_0.ts, 13, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 15, 20)) +>pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 8, 5), Decl(declFileAccessors_0.ts, 12, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 14, 20)) } /** static getter property*/ static get s3() { ->s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 16, 5), Decl(declFileAccessors_0.ts, 20, 5)) +>s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 15, 5), Decl(declFileAccessors_0.ts, 19, 5)) return 10; } /** setter property*/ static set s3( /** this is value*/value: number) { ->s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 16, 5), Decl(declFileAccessors_0.ts, 20, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 22, 18)) +>s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 15, 5), Decl(declFileAccessors_0.ts, 19, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 21, 18)) } public get nc_p3() { ->nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 23, 5), Decl(declFileAccessors_0.ts, 26, 5)) +>nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 22, 5), Decl(declFileAccessors_0.ts, 25, 5)) return 10; } public set nc_p3(value: number) { ->nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 23, 5), Decl(declFileAccessors_0.ts, 26, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 27, 21)) +>nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 22, 5), Decl(declFileAccessors_0.ts, 25, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 26, 21)) } private get nc_pp3() { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 28, 5), Decl(declFileAccessors_0.ts, 31, 5)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 27, 5), Decl(declFileAccessors_0.ts, 30, 5)) return 10; } private set nc_pp3(value: number) { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 28, 5), Decl(declFileAccessors_0.ts, 31, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 32, 23)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 27, 5), Decl(declFileAccessors_0.ts, 30, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 31, 23)) } static get nc_s3() { ->nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 33, 5), Decl(declFileAccessors_0.ts, 36, 5)) +>nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 32, 5), Decl(declFileAccessors_0.ts, 35, 5)) return ""; } static set nc_s3(value: string) { ->nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 33, 5), Decl(declFileAccessors_0.ts, 36, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 37, 21)) +>nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 32, 5), Decl(declFileAccessors_0.ts, 35, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 36, 21)) } // Only getter property public get onlyGetter() { ->onlyGetter : Symbol(c1.onlyGetter, Decl(declFileAccessors_0.ts, 38, 5)) +>onlyGetter : Symbol(c1.onlyGetter, Decl(declFileAccessors_0.ts, 37, 5)) return 10; } // Only setter property public set onlySetter(value: number) { ->onlySetter : Symbol(c1.onlySetter, Decl(declFileAccessors_0.ts, 43, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 46, 26)) +>onlySetter : Symbol(c1.onlySetter, Decl(declFileAccessors_0.ts, 42, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 45, 26)) } } diff --git a/tests/baselines/reference/declFileAccessors.types b/tests/baselines/reference/declFileAccessors.types index a038c66b271..797f5433e42 100644 --- a/tests/baselines/reference/declFileAccessors.types +++ b/tests/baselines/reference/declFileAccessors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileAccessors_0.ts === - /** This is comment for c1*/ export class c1 { >c1 : c1 diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js index 56b8992811b..2269f85996f 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileAliasUseBeforeDeclaration.ts] //// //// [declFileAliasUseBeforeDeclaration_foo.ts] - export class Foo { } //// [declFileAliasUseBeforeDeclaration_test.ts] diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols index ba74b6cdfb7..cd890bf4256 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols @@ -9,7 +9,6 @@ import foo = require("./declFileAliasUseBeforeDeclaration_foo"); >foo : Symbol(foo, Decl(declFileAliasUseBeforeDeclaration_test.ts, 0, 35)) === tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts === - export class Foo { } >Foo : Symbol(Foo, Decl(declFileAliasUseBeforeDeclaration_foo.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types index 544efded5ee..0b2c98e808c 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types @@ -9,7 +9,6 @@ import foo = require("./declFileAliasUseBeforeDeclaration_foo"); >foo : typeof foo === tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts === - export class Foo { } >Foo : Foo diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js index 905a298bd32..ef8db581de4 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js @@ -1,5 +1,4 @@ //// [declFileAliasUseBeforeDeclaration2.ts] - declare module "test" { module A { class C { diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols index c0ad98bbe3d..16cd0938541 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/declFileAliasUseBeforeDeclaration2.ts === - declare module "test" { module A { ->A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 23)) +>A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 0, 23)) class C { ->C : Symbol(C, Decl(declFileAliasUseBeforeDeclaration2.ts, 2, 14)) +>C : Symbol(C, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 14)) } } class B extends E { ->B : Symbol(B, Decl(declFileAliasUseBeforeDeclaration2.ts, 5, 5)) ->E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 7, 5)) +>B : Symbol(B, Decl(declFileAliasUseBeforeDeclaration2.ts, 4, 5)) +>E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 6, 5)) } import E = A.C; ->E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 7, 5)) ->A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 23)) ->C : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 2, 14)) +>E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 6, 5)) +>A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 0, 23)) +>C : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 14)) } diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types index 362dd031e09..a51c79e044c 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileAliasUseBeforeDeclaration2.ts === - declare module "test" { module A { >A : typeof A diff --git a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js index 6d626e2963d..627a1865d8f 100644 --- a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js +++ b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileAmbientExternalModuleWithSingleExportedModule.ts] //// //// [declFileAmbientExternalModuleWithSingleExportedModule_0.ts] - declare module "SubModule" { export module m { export module m3 { diff --git a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols index 4a4077836cd..942d4a155f2 100644 --- a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols +++ b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols @@ -6,22 +6,21 @@ import SubModule = require('SubModule'); export var x: SubModule.m.m3.c; >x : Symbol(x, Decl(declFileAmbientExternalModuleWithSingleExportedModule_1.ts, 2, 10)) >SubModule : Symbol(SubModule, Decl(declFileAmbientExternalModuleWithSingleExportedModule_1.ts, 0, 0)) ->m : Symbol(SubModule.m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 28)) ->m3 : Symbol(SubModule.m.m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 21)) ->c : Symbol(SubModule.m.m3.c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 3, 26)) +>m : Symbol(SubModule.m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 0, 28)) +>m3 : Symbol(SubModule.m.m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 21)) +>c : Symbol(SubModule.m.m3.c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 26)) === tests/cases/compiler/declFileAmbientExternalModuleWithSingleExportedModule_0.ts === - declare module "SubModule" { export module m { ->m : Symbol(m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 28)) +>m : Symbol(m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 0, 28)) export module m3 { ->m3 : Symbol(m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 21)) +>m3 : Symbol(m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 21)) interface c { ->c : Symbol(c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 3, 26)) +>c : Symbol(c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 26)) } } } diff --git a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types index 792f1f0282f..2332302cead 100644 --- a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types +++ b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types @@ -12,7 +12,6 @@ export var x: SubModule.m.m3.c; === tests/cases/compiler/declFileAmbientExternalModuleWithSingleExportedModule_0.ts === - declare module "SubModule" { export module m { >m : any diff --git a/tests/baselines/reference/declFileCallSignatures.js b/tests/baselines/reference/declFileCallSignatures.js index 8f79ae6341e..7c0e6d8b0a5 100644 --- a/tests/baselines/reference/declFileCallSignatures.js +++ b/tests/baselines/reference/declFileCallSignatures.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileCallSignatures.ts] //// //// [declFileCallSignatures_0.ts] - export interface ICallSignature { /** This comment should appear for foo*/ (): string; diff --git a/tests/baselines/reference/declFileCallSignatures.symbols b/tests/baselines/reference/declFileCallSignatures.symbols index cf1697dc4c0..2034ffe5bde 100644 --- a/tests/baselines/reference/declFileCallSignatures.symbols +++ b/tests/baselines/reference/declFileCallSignatures.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileCallSignatures_0.ts === - export interface ICallSignature { >ICallSignature : Symbol(ICallSignature, Decl(declFileCallSignatures_0.ts, 0, 0)) @@ -8,53 +7,53 @@ export interface ICallSignature { } export interface ICallSignatureWithParameters { ->ICallSignatureWithParameters : Symbol(ICallSignatureWithParameters, Decl(declFileCallSignatures_0.ts, 4, 1)) +>ICallSignatureWithParameters : Symbol(ICallSignatureWithParameters, Decl(declFileCallSignatures_0.ts, 3, 1)) /** This is comment for function signature*/ (/** this is comment about a*/a: string, ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 8, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 7, 5)) /** this is comment for b*/ b: number): void; ->b : Symbol(b, Decl(declFileCallSignatures_0.ts, 8, 44)) +>b : Symbol(b, Decl(declFileCallSignatures_0.ts, 7, 44)) } export interface ICallSignatureWithRestParameters { ->ICallSignatureWithRestParameters : Symbol(ICallSignatureWithRestParameters, Decl(declFileCallSignatures_0.ts, 11, 1)) +>ICallSignatureWithRestParameters : Symbol(ICallSignatureWithRestParameters, Decl(declFileCallSignatures_0.ts, 10, 1)) (a: string, ...rests: string[]): string; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 14, 5)) ->rests : Symbol(rests, Decl(declFileCallSignatures_0.ts, 14, 15)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 13, 5)) +>rests : Symbol(rests, Decl(declFileCallSignatures_0.ts, 13, 15)) } export interface ICallSignatureWithOverloads { ->ICallSignatureWithOverloads : Symbol(ICallSignatureWithOverloads, Decl(declFileCallSignatures_0.ts, 15, 1)) +>ICallSignatureWithOverloads : Symbol(ICallSignatureWithOverloads, Decl(declFileCallSignatures_0.ts, 14, 1)) (a: string): string; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 18, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 17, 5)) (a: number): number; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 19, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 18, 5)) } export interface ICallSignatureWithTypeParameters { ->ICallSignatureWithTypeParameters : Symbol(ICallSignatureWithTypeParameters, Decl(declFileCallSignatures_0.ts, 20, 1)) ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 22, 50)) +>ICallSignatureWithTypeParameters : Symbol(ICallSignatureWithTypeParameters, Decl(declFileCallSignatures_0.ts, 19, 1)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 21, 50)) /** This comment should appear for foo*/ (a: T): string; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 24, 5)) ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 22, 50)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 23, 5)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 21, 50)) } export interface ICallSignatureWithOwnTypeParametes { ->ICallSignatureWithOwnTypeParametes : Symbol(ICallSignatureWithOwnTypeParametes, Decl(declFileCallSignatures_0.ts, 25, 1)) +>ICallSignatureWithOwnTypeParametes : Symbol(ICallSignatureWithOwnTypeParametes, Decl(declFileCallSignatures_0.ts, 24, 1)) (a: T): string; ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 28, 5)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 27, 5)) >ICallSignature : Symbol(ICallSignature, Decl(declFileCallSignatures_0.ts, 0, 0)) ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 28, 31)) ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 28, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 27, 31)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 27, 5)) } === tests/cases/compiler/declFileCallSignatures_1.ts === diff --git a/tests/baselines/reference/declFileCallSignatures.types b/tests/baselines/reference/declFileCallSignatures.types index 0fc0757aee1..ec5ab9a26cf 100644 --- a/tests/baselines/reference/declFileCallSignatures.types +++ b/tests/baselines/reference/declFileCallSignatures.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileCallSignatures_0.ts === - export interface ICallSignature { >ICallSignature : ICallSignature diff --git a/tests/baselines/reference/declFileClassExtendsNull.js b/tests/baselines/reference/declFileClassExtendsNull.js index a7ea02011fe..5e2da40442b 100644 --- a/tests/baselines/reference/declFileClassExtendsNull.js +++ b/tests/baselines/reference/declFileClassExtendsNull.js @@ -1,5 +1,4 @@ //// [declFileClassExtendsNull.ts] - class ExtendsNull extends null { } diff --git a/tests/baselines/reference/declFileClassExtendsNull.symbols b/tests/baselines/reference/declFileClassExtendsNull.symbols index e86276faad8..09e7744fa16 100644 --- a/tests/baselines/reference/declFileClassExtendsNull.symbols +++ b/tests/baselines/reference/declFileClassExtendsNull.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassExtendsNull.ts === - class ExtendsNull extends null { >ExtendsNull : Symbol(ExtendsNull, Decl(declFileClassExtendsNull.ts, 0, 0)) } diff --git a/tests/baselines/reference/declFileClassExtendsNull.types b/tests/baselines/reference/declFileClassExtendsNull.types index bbd43d99c0d..7fc519ac0d6 100644 --- a/tests/baselines/reference/declFileClassExtendsNull.types +++ b/tests/baselines/reference/declFileClassExtendsNull.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassExtendsNull.ts === - class ExtendsNull extends null { >ExtendsNull : ExtendsNull >null : null diff --git a/tests/baselines/reference/declFileClassWithIndexSignature.js b/tests/baselines/reference/declFileClassWithIndexSignature.js index 31369db6660..46969b18755 100644 --- a/tests/baselines/reference/declFileClassWithIndexSignature.js +++ b/tests/baselines/reference/declFileClassWithIndexSignature.js @@ -1,5 +1,4 @@ //// [declFileClassWithIndexSignature.ts] - class BlockIntrinsics { [s: string]: string; } diff --git a/tests/baselines/reference/declFileClassWithIndexSignature.symbols b/tests/baselines/reference/declFileClassWithIndexSignature.symbols index 2487a2fae00..5b0cce6df16 100644 --- a/tests/baselines/reference/declFileClassWithIndexSignature.symbols +++ b/tests/baselines/reference/declFileClassWithIndexSignature.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/declFileClassWithIndexSignature.ts === - class BlockIntrinsics { >BlockIntrinsics : Symbol(BlockIntrinsics, Decl(declFileClassWithIndexSignature.ts, 0, 0)) [s: string]: string; ->s : Symbol(s, Decl(declFileClassWithIndexSignature.ts, 2, 5)) +>s : Symbol(s, Decl(declFileClassWithIndexSignature.ts, 1, 5)) } diff --git a/tests/baselines/reference/declFileClassWithIndexSignature.types b/tests/baselines/reference/declFileClassWithIndexSignature.types index 16aa108c3c1..5f587eb43a1 100644 --- a/tests/baselines/reference/declFileClassWithIndexSignature.types +++ b/tests/baselines/reference/declFileClassWithIndexSignature.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassWithIndexSignature.ts === - class BlockIntrinsics { >BlockIntrinsics : BlockIntrinsics diff --git a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js index ee1964415c9..4ac309c1a6b 100644 --- a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js +++ b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js @@ -1,5 +1,4 @@ //// [declFileClassWithStaticMethodReturningConstructor.ts] - export class Enhancement { public static getType() { return this; diff --git a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols index af1f56642bc..a08baa50179 100644 --- a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols +++ b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/declFileClassWithStaticMethodReturningConstructor.ts === - export class Enhancement { >Enhancement : Symbol(Enhancement, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 0, 0)) public static getType() { ->getType : Symbol(Enhancement.getType, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 1, 26)) +>getType : Symbol(Enhancement.getType, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 0, 26)) return this; >this : Symbol(Enhancement, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types index 0f1b21efc9e..cfecdccd4c6 100644 --- a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types +++ b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassWithStaticMethodReturningConstructor.ts === - export class Enhancement { >Enhancement : Enhancement diff --git a/tests/baselines/reference/declFileConstructSignatures.js b/tests/baselines/reference/declFileConstructSignatures.js index 309f7133873..dd9dd7f8908 100644 --- a/tests/baselines/reference/declFileConstructSignatures.js +++ b/tests/baselines/reference/declFileConstructSignatures.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileConstructSignatures.ts] //// //// [declFileConstructSignatures_0.ts] - export interface IConstructSignature { /** This comment should appear for foo*/ new (): string; diff --git a/tests/baselines/reference/declFileConstructSignatures.symbols b/tests/baselines/reference/declFileConstructSignatures.symbols index a6d98f6feca..29f6a3af50f 100644 --- a/tests/baselines/reference/declFileConstructSignatures.symbols +++ b/tests/baselines/reference/declFileConstructSignatures.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructSignatures_0.ts === - export interface IConstructSignature { >IConstructSignature : Symbol(IConstructSignature, Decl(declFileConstructSignatures_0.ts, 0, 0)) @@ -8,55 +7,55 @@ export interface IConstructSignature { } export interface IConstructSignatureWithParameters { ->IConstructSignatureWithParameters : Symbol(IConstructSignatureWithParameters, Decl(declFileConstructSignatures_0.ts, 4, 1)) +>IConstructSignatureWithParameters : Symbol(IConstructSignatureWithParameters, Decl(declFileConstructSignatures_0.ts, 3, 1)) /** This is comment for function signature*/ new (/** this is comment about a*/a: string, ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 8, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 7, 9)) /** this is comment for b*/ b: number); ->b : Symbol(b, Decl(declFileConstructSignatures_0.ts, 8, 48)) +>b : Symbol(b, Decl(declFileConstructSignatures_0.ts, 7, 48)) } export interface IConstructSignatureWithRestParameters { ->IConstructSignatureWithRestParameters : Symbol(IConstructSignatureWithRestParameters, Decl(declFileConstructSignatures_0.ts, 11, 1)) +>IConstructSignatureWithRestParameters : Symbol(IConstructSignatureWithRestParameters, Decl(declFileConstructSignatures_0.ts, 10, 1)) new (a: string, ...rests: string[]): string; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 14, 9)) ->rests : Symbol(rests, Decl(declFileConstructSignatures_0.ts, 14, 19)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 13, 9)) +>rests : Symbol(rests, Decl(declFileConstructSignatures_0.ts, 13, 19)) } export interface IConstructSignatureWithOverloads { ->IConstructSignatureWithOverloads : Symbol(IConstructSignatureWithOverloads, Decl(declFileConstructSignatures_0.ts, 15, 1)) +>IConstructSignatureWithOverloads : Symbol(IConstructSignatureWithOverloads, Decl(declFileConstructSignatures_0.ts, 14, 1)) new (a: string): string; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 18, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 17, 9)) new (a: number): number; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 19, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 18, 9)) } export interface IConstructSignatureWithTypeParameters { ->IConstructSignatureWithTypeParameters : Symbol(IConstructSignatureWithTypeParameters, Decl(declFileConstructSignatures_0.ts, 20, 1)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 22, 55)) +>IConstructSignatureWithTypeParameters : Symbol(IConstructSignatureWithTypeParameters, Decl(declFileConstructSignatures_0.ts, 19, 1)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 21, 55)) /** This comment should appear for foo*/ new (a: T): T; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 24, 9)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 22, 55)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 22, 55)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 23, 9)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 21, 55)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 21, 55)) } export interface IConstructSignatureWithOwnTypeParametes { ->IConstructSignatureWithOwnTypeParametes : Symbol(IConstructSignatureWithOwnTypeParametes, Decl(declFileConstructSignatures_0.ts, 25, 1)) +>IConstructSignatureWithOwnTypeParametes : Symbol(IConstructSignatureWithOwnTypeParametes, Decl(declFileConstructSignatures_0.ts, 24, 1)) new (a: T): T; ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 28, 9)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 27, 9)) >IConstructSignature : Symbol(IConstructSignature, Decl(declFileConstructSignatures_0.ts, 0, 0)) ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 28, 40)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 28, 9)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 28, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 27, 40)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 27, 9)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 27, 9)) } === tests/cases/compiler/declFileConstructSignatures_1.ts === diff --git a/tests/baselines/reference/declFileConstructSignatures.types b/tests/baselines/reference/declFileConstructSignatures.types index 6ee19bfdcf7..72a73db82c6 100644 --- a/tests/baselines/reference/declFileConstructSignatures.types +++ b/tests/baselines/reference/declFileConstructSignatures.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructSignatures_0.ts === - export interface IConstructSignature { >IConstructSignature : IConstructSignature diff --git a/tests/baselines/reference/declFileConstructors.js b/tests/baselines/reference/declFileConstructors.js index 214620193b7..95e28cc92d6 100644 --- a/tests/baselines/reference/declFileConstructors.js +++ b/tests/baselines/reference/declFileConstructors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileConstructors.ts] //// //// [declFileConstructors_0.ts] - export class SimpleConstructor { /** This comment should appear for foo*/ constructor() { diff --git a/tests/baselines/reference/declFileConstructors.symbols b/tests/baselines/reference/declFileConstructors.symbols index ad86b6a721f..2d7d1cd4a6a 100644 --- a/tests/baselines/reference/declFileConstructors.symbols +++ b/tests/baselines/reference/declFileConstructors.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructors_0.ts === - export class SimpleConstructor { >SimpleConstructor : Symbol(SimpleConstructor, Decl(declFileConstructors_0.ts, 0, 0)) @@ -8,80 +7,80 @@ export class SimpleConstructor { } } export class ConstructorWithParameters { ->ConstructorWithParameters : Symbol(ConstructorWithParameters, Decl(declFileConstructors_0.ts, 5, 1)) +>ConstructorWithParameters : Symbol(ConstructorWithParameters, Decl(declFileConstructors_0.ts, 4, 1)) /** This is comment for function signature*/ constructor(/** this is comment about a*/a: string, ->a : Symbol(a, Decl(declFileConstructors_0.ts, 8, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 7, 16)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileConstructors_0.ts, 8, 55)) +>b : Symbol(b, Decl(declFileConstructors_0.ts, 7, 55)) var d = a; ->d : Symbol(d, Decl(declFileConstructors_0.ts, 11, 11)) ->a : Symbol(a, Decl(declFileConstructors_0.ts, 8, 16)) +>d : Symbol(d, Decl(declFileConstructors_0.ts, 10, 11)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 7, 16)) } } export class ConstructorWithRestParamters { ->ConstructorWithRestParamters : Symbol(ConstructorWithRestParamters, Decl(declFileConstructors_0.ts, 13, 1)) +>ConstructorWithRestParamters : Symbol(ConstructorWithRestParamters, Decl(declFileConstructors_0.ts, 12, 1)) constructor(a: string, ...rests: string[]) { ->a : Symbol(a, Decl(declFileConstructors_0.ts, 16, 16)) ->rests : Symbol(rests, Decl(declFileConstructors_0.ts, 16, 26)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 15, 16)) +>rests : Symbol(rests, Decl(declFileConstructors_0.ts, 15, 26)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileConstructors_0.ts, 16, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 15, 16)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileConstructors_0.ts, 16, 26)) +>rests : Symbol(rests, Decl(declFileConstructors_0.ts, 15, 26)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } } export class ConstructorWithOverloads { ->ConstructorWithOverloads : Symbol(ConstructorWithOverloads, Decl(declFileConstructors_0.ts, 19, 1)) +>ConstructorWithOverloads : Symbol(ConstructorWithOverloads, Decl(declFileConstructors_0.ts, 18, 1)) constructor(a: string); ->a : Symbol(a, Decl(declFileConstructors_0.ts, 22, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 21, 16)) constructor(a: number); ->a : Symbol(a, Decl(declFileConstructors_0.ts, 23, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 22, 16)) constructor(a: any) { ->a : Symbol(a, Decl(declFileConstructors_0.ts, 24, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 23, 16)) } } export class ConstructorWithPublicParameterProperty { ->ConstructorWithPublicParameterProperty : Symbol(ConstructorWithPublicParameterProperty, Decl(declFileConstructors_0.ts, 26, 1)) +>ConstructorWithPublicParameterProperty : Symbol(ConstructorWithPublicParameterProperty, Decl(declFileConstructors_0.ts, 25, 1)) constructor(public x: string) { ->x : Symbol(ConstructorWithPublicParameterProperty.x, Decl(declFileConstructors_0.ts, 29, 16)) +>x : Symbol(ConstructorWithPublicParameterProperty.x, Decl(declFileConstructors_0.ts, 28, 16)) } } export class ConstructorWithPrivateParameterProperty { ->ConstructorWithPrivateParameterProperty : Symbol(ConstructorWithPrivateParameterProperty, Decl(declFileConstructors_0.ts, 31, 1)) +>ConstructorWithPrivateParameterProperty : Symbol(ConstructorWithPrivateParameterProperty, Decl(declFileConstructors_0.ts, 30, 1)) constructor(private x: string) { ->x : Symbol(ConstructorWithPrivateParameterProperty.x, Decl(declFileConstructors_0.ts, 34, 16)) +>x : Symbol(ConstructorWithPrivateParameterProperty.x, Decl(declFileConstructors_0.ts, 33, 16)) } } export class ConstructorWithOptionalParameterProperty { ->ConstructorWithOptionalParameterProperty : Symbol(ConstructorWithOptionalParameterProperty, Decl(declFileConstructors_0.ts, 36, 1)) +>ConstructorWithOptionalParameterProperty : Symbol(ConstructorWithOptionalParameterProperty, Decl(declFileConstructors_0.ts, 35, 1)) constructor(public x?: string) { ->x : Symbol(ConstructorWithOptionalParameterProperty.x, Decl(declFileConstructors_0.ts, 39, 16)) +>x : Symbol(ConstructorWithOptionalParameterProperty.x, Decl(declFileConstructors_0.ts, 38, 16)) } } export class ConstructorWithParameterInitializer { ->ConstructorWithParameterInitializer : Symbol(ConstructorWithParameterInitializer, Decl(declFileConstructors_0.ts, 41, 1)) +>ConstructorWithParameterInitializer : Symbol(ConstructorWithParameterInitializer, Decl(declFileConstructors_0.ts, 40, 1)) constructor(public x = "hello") { ->x : Symbol(ConstructorWithParameterInitializer.x, Decl(declFileConstructors_0.ts, 44, 16)) +>x : Symbol(ConstructorWithParameterInitializer.x, Decl(declFileConstructors_0.ts, 43, 16)) } } diff --git a/tests/baselines/reference/declFileConstructors.types b/tests/baselines/reference/declFileConstructors.types index 733a624e776..179db643bcb 100644 --- a/tests/baselines/reference/declFileConstructors.types +++ b/tests/baselines/reference/declFileConstructors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructors_0.ts === - export class SimpleConstructor { >SimpleConstructor : SimpleConstructor diff --git a/tests/baselines/reference/declFileEnumUsedAsValue.js b/tests/baselines/reference/declFileEnumUsedAsValue.js index c42f70402b3..23afd5da8b0 100644 --- a/tests/baselines/reference/declFileEnumUsedAsValue.js +++ b/tests/baselines/reference/declFileEnumUsedAsValue.js @@ -1,5 +1,4 @@ //// [declFileEnumUsedAsValue.ts] - enum e { a, b, diff --git a/tests/baselines/reference/declFileEnumUsedAsValue.symbols b/tests/baselines/reference/declFileEnumUsedAsValue.symbols index d24852c6260..d0409fe0211 100644 --- a/tests/baselines/reference/declFileEnumUsedAsValue.symbols +++ b/tests/baselines/reference/declFileEnumUsedAsValue.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/declFileEnumUsedAsValue.ts === - enum e { >e : Symbol(e, Decl(declFileEnumUsedAsValue.ts, 0, 0)) a, ->a : Symbol(e.a, Decl(declFileEnumUsedAsValue.ts, 1, 8)) +>a : Symbol(e.a, Decl(declFileEnumUsedAsValue.ts, 0, 8)) b, ->b : Symbol(e.b, Decl(declFileEnumUsedAsValue.ts, 2, 6)) +>b : Symbol(e.b, Decl(declFileEnumUsedAsValue.ts, 1, 6)) c ->c : Symbol(e.c, Decl(declFileEnumUsedAsValue.ts, 3, 6)) +>c : Symbol(e.c, Decl(declFileEnumUsedAsValue.ts, 2, 6)) } var x = e; ->x : Symbol(x, Decl(declFileEnumUsedAsValue.ts, 6, 3)) +>x : Symbol(x, Decl(declFileEnumUsedAsValue.ts, 5, 3)) >e : Symbol(e, Decl(declFileEnumUsedAsValue.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileEnumUsedAsValue.types b/tests/baselines/reference/declFileEnumUsedAsValue.types index fe323095922..d4601cbacae 100644 --- a/tests/baselines/reference/declFileEnumUsedAsValue.types +++ b/tests/baselines/reference/declFileEnumUsedAsValue.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileEnumUsedAsValue.ts === - enum e { >e : e diff --git a/tests/baselines/reference/declFileEnums.js b/tests/baselines/reference/declFileEnums.js index 34f1e386a96..d8027ca442f 100644 --- a/tests/baselines/reference/declFileEnums.js +++ b/tests/baselines/reference/declFileEnums.js @@ -1,5 +1,4 @@ //// [declFileEnums.ts] - enum e1 { a, b, diff --git a/tests/baselines/reference/declFileEnums.symbols b/tests/baselines/reference/declFileEnums.symbols index bea118ea967..e236509f6b1 100644 --- a/tests/baselines/reference/declFileEnums.symbols +++ b/tests/baselines/reference/declFileEnums.symbols @@ -1,70 +1,69 @@ === tests/cases/compiler/declFileEnums.ts === - enum e1 { >e1 : Symbol(e1, Decl(declFileEnums.ts, 0, 0)) a, ->a : Symbol(e1.a, Decl(declFileEnums.ts, 1, 9)) +>a : Symbol(e1.a, Decl(declFileEnums.ts, 0, 9)) b, ->b : Symbol(e1.b, Decl(declFileEnums.ts, 2, 6)) +>b : Symbol(e1.b, Decl(declFileEnums.ts, 1, 6)) c ->c : Symbol(e1.c, Decl(declFileEnums.ts, 3, 6)) +>c : Symbol(e1.c, Decl(declFileEnums.ts, 2, 6)) } enum e2 { ->e2 : Symbol(e2, Decl(declFileEnums.ts, 5, 1)) +>e2 : Symbol(e2, Decl(declFileEnums.ts, 4, 1)) a = 10, ->a : Symbol(e2.a, Decl(declFileEnums.ts, 7, 9)) +>a : Symbol(e2.a, Decl(declFileEnums.ts, 6, 9)) b = a + 2, ->b : Symbol(e2.b, Decl(declFileEnums.ts, 8, 11)) ->a : Symbol(e2.a, Decl(declFileEnums.ts, 7, 9)) +>b : Symbol(e2.b, Decl(declFileEnums.ts, 7, 11)) +>a : Symbol(e2.a, Decl(declFileEnums.ts, 6, 9)) c = 10, ->c : Symbol(e2.c, Decl(declFileEnums.ts, 9, 14)) +>c : Symbol(e2.c, Decl(declFileEnums.ts, 8, 14)) } enum e3 { ->e3 : Symbol(e3, Decl(declFileEnums.ts, 11, 1)) +>e3 : Symbol(e3, Decl(declFileEnums.ts, 10, 1)) a = 10, ->a : Symbol(e3.a, Decl(declFileEnums.ts, 13, 9)) +>a : Symbol(e3.a, Decl(declFileEnums.ts, 12, 9)) b = Math.PI, ->b : Symbol(e3.b, Decl(declFileEnums.ts, 14, 11)) +>b : Symbol(e3.b, Decl(declFileEnums.ts, 13, 11)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) c = a + 3 ->c : Symbol(e3.c, Decl(declFileEnums.ts, 15, 16)) ->a : Symbol(e3.a, Decl(declFileEnums.ts, 13, 9)) +>c : Symbol(e3.c, Decl(declFileEnums.ts, 14, 16)) +>a : Symbol(e3.a, Decl(declFileEnums.ts, 12, 9)) } enum e4 { ->e4 : Symbol(e4, Decl(declFileEnums.ts, 17, 1)) +>e4 : Symbol(e4, Decl(declFileEnums.ts, 16, 1)) a, ->a : Symbol(e4.a, Decl(declFileEnums.ts, 19, 9)) +>a : Symbol(e4.a, Decl(declFileEnums.ts, 18, 9)) b, ->b : Symbol(e4.b, Decl(declFileEnums.ts, 20, 6)) +>b : Symbol(e4.b, Decl(declFileEnums.ts, 19, 6)) c, ->c : Symbol(e4.c, Decl(declFileEnums.ts, 21, 6)) +>c : Symbol(e4.c, Decl(declFileEnums.ts, 20, 6)) d = 10, ->d : Symbol(e4.d, Decl(declFileEnums.ts, 22, 6)) +>d : Symbol(e4.d, Decl(declFileEnums.ts, 21, 6)) e ->e : Symbol(e4.e, Decl(declFileEnums.ts, 23, 11)) +>e : Symbol(e4.e, Decl(declFileEnums.ts, 22, 11)) } enum e5 { ->e5 : Symbol(e5, Decl(declFileEnums.ts, 25, 1)) +>e5 : Symbol(e5, Decl(declFileEnums.ts, 24, 1)) "Friday", "Saturday", diff --git a/tests/baselines/reference/declFileEnums.types b/tests/baselines/reference/declFileEnums.types index 5b0bfff5bed..eb13d3bbf67 100644 --- a/tests/baselines/reference/declFileEnums.types +++ b/tests/baselines/reference/declFileEnums.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileEnums.ts === - enum e1 { >e1 : e1 diff --git a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js index 1caa9207193..cefff0be4ea 100644 --- a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js +++ b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileExportAssignmentOfGenericInterface.ts] //// //// [declFileExportAssignmentOfGenericInterface_0.ts] - interface Foo { a: string; } diff --git a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols index 34b1cbff341..4499c321c5e 100644 --- a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols +++ b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols @@ -8,18 +8,17 @@ export var x: a>; >a : Symbol(a, Decl(declFileExportAssignmentOfGenericInterface_1.ts, 0, 0)) x.a; ->x.a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 18)) +>x.a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 18)) >x : Symbol(x, Decl(declFileExportAssignmentOfGenericInterface_1.ts, 1, 10)) ->a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 18)) +>a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 18)) === tests/cases/compiler/declFileExportAssignmentOfGenericInterface_0.ts === - interface Foo { >Foo : Symbol(Foo, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 0)) ->T : Symbol(T, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 14)) +>T : Symbol(T, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 14)) a: string; ->a : Symbol(Foo.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 18)) +>a : Symbol(Foo.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 18)) } export = Foo; >Foo : Symbol(Foo, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types index 59c604540b9..126f63a6ac9 100644 --- a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types +++ b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types @@ -13,7 +13,6 @@ x.a; >a : string === tests/cases/compiler/declFileExportAssignmentOfGenericInterface_0.ts === - interface Foo { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declFileExportImportChain.js b/tests/baselines/reference/declFileExportImportChain.js index 2af2103b62a..fe1b36d76fa 100644 --- a/tests/baselines/reference/declFileExportImportChain.js +++ b/tests/baselines/reference/declFileExportImportChain.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileExportImportChain.ts] //// //// [declFileExportImportChain_a.ts] - module m1 { export module m2 { export class c1 { diff --git a/tests/baselines/reference/declFileExportImportChain.symbols b/tests/baselines/reference/declFileExportImportChain.symbols index 6e59fa2c167..364ccf28234 100644 --- a/tests/baselines/reference/declFileExportImportChain.symbols +++ b/tests/baselines/reference/declFileExportImportChain.symbols @@ -7,19 +7,18 @@ export var x: c.b1.a.m2.c1; >c : Symbol(c, Decl(declFileExportImportChain_d.ts, 0, 0)) >b1 : Symbol(c.b1, Decl(declFileExportImportChain_c.ts, 0, 0)) >a : Symbol(c.b1.a, Decl(declFileExportImportChain_b.ts, 0, 0)) ->m2 : Symbol(c.b1.a.m2, Decl(declFileExportImportChain_a.ts, 1, 11)) ->c1 : Symbol(c.b1.a.m2.c1, Decl(declFileExportImportChain_a.ts, 2, 22)) +>m2 : Symbol(c.b1.a.m2, Decl(declFileExportImportChain_a.ts, 0, 11)) +>c1 : Symbol(c.b1.a.m2.c1, Decl(declFileExportImportChain_a.ts, 1, 22)) === tests/cases/compiler/declFileExportImportChain_a.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileExportImportChain_a.ts, 0, 0)) export module m2 { ->m2 : Symbol(m2, Decl(declFileExportImportChain_a.ts, 1, 11)) +>m2 : Symbol(m2, Decl(declFileExportImportChain_a.ts, 0, 11)) export class c1 { ->c1 : Symbol(c1, Decl(declFileExportImportChain_a.ts, 2, 22)) +>c1 : Symbol(c1, Decl(declFileExportImportChain_a.ts, 1, 22)) } } } diff --git a/tests/baselines/reference/declFileExportImportChain.types b/tests/baselines/reference/declFileExportImportChain.types index f9601adb147..e89a8974f13 100644 --- a/tests/baselines/reference/declFileExportImportChain.types +++ b/tests/baselines/reference/declFileExportImportChain.types @@ -11,7 +11,6 @@ export var x: c.b1.a.m2.c1; >c1 : c.b1.a.m2.c1 === tests/cases/compiler/declFileExportImportChain_a.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileExportImportChain2.js b/tests/baselines/reference/declFileExportImportChain2.js index 70478fdf430..ec7629ebed1 100644 --- a/tests/baselines/reference/declFileExportImportChain2.js +++ b/tests/baselines/reference/declFileExportImportChain2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileExportImportChain2.ts] //// //// [declFileExportImportChain2_a.ts] - module m1 { export module m2 { export class c1 { diff --git a/tests/baselines/reference/declFileExportImportChain2.symbols b/tests/baselines/reference/declFileExportImportChain2.symbols index e5a80c87f9e..0543bcbcbb8 100644 --- a/tests/baselines/reference/declFileExportImportChain2.symbols +++ b/tests/baselines/reference/declFileExportImportChain2.symbols @@ -6,19 +6,18 @@ export var x: c.b.m2.c1; >x : Symbol(x, Decl(declFileExportImportChain2_d.ts, 1, 10)) >c : Symbol(c, Decl(declFileExportImportChain2_d.ts, 0, 0)) >b : Symbol(c.b, Decl(declFileExportImportChain2_c.ts, 0, 0)) ->m2 : Symbol(c.b.m2, Decl(declFileExportImportChain2_a.ts, 1, 11)) ->c1 : Symbol(c.b.m2.c1, Decl(declFileExportImportChain2_a.ts, 2, 22)) +>m2 : Symbol(c.b.m2, Decl(declFileExportImportChain2_a.ts, 0, 11)) +>c1 : Symbol(c.b.m2.c1, Decl(declFileExportImportChain2_a.ts, 1, 22)) === tests/cases/compiler/declFileExportImportChain2_a.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileExportImportChain2_a.ts, 0, 0)) export module m2 { ->m2 : Symbol(m2, Decl(declFileExportImportChain2_a.ts, 1, 11)) +>m2 : Symbol(m2, Decl(declFileExportImportChain2_a.ts, 0, 11)) export class c1 { ->c1 : Symbol(c1, Decl(declFileExportImportChain2_a.ts, 2, 22)) +>c1 : Symbol(c1, Decl(declFileExportImportChain2_a.ts, 1, 22)) } } } diff --git a/tests/baselines/reference/declFileExportImportChain2.types b/tests/baselines/reference/declFileExportImportChain2.types index 9c583180404..c2978359074 100644 --- a/tests/baselines/reference/declFileExportImportChain2.types +++ b/tests/baselines/reference/declFileExportImportChain2.types @@ -10,7 +10,6 @@ export var x: c.b.m2.c1; >c1 : c.b.m2.c1 === tests/cases/compiler/declFileExportImportChain2_a.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js index dda944bef3d..a1d9f87d483 100644 --- a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js +++ b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js @@ -1,5 +1,4 @@ //// [declFileForClassWithMultipleBaseClasses.ts] - class A { foo() { } } diff --git a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols index 92c82d6ed41..9da0b9a5c85 100644 --- a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols +++ b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols @@ -1,54 +1,53 @@ === tests/cases/compiler/declFileForClassWithMultipleBaseClasses.ts === - class A { >A : Symbol(A, Decl(declFileForClassWithMultipleBaseClasses.ts, 0, 0)) foo() { } ->foo : Symbol(A.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 1, 9)) +>foo : Symbol(A.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 0, 9)) } class B { ->B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 3, 1)) +>B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 2, 1)) bar() { } ->bar : Symbol(B.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 5, 9)) +>bar : Symbol(B.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 4, 9)) } interface I { ->I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 7, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 23, 1)) +>I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 6, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 22, 1)) baz(); ->baz : Symbol(I.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 9, 13)) +>baz : Symbol(I.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 8, 13)) } interface J { ->J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 11, 1)) +>J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 10, 1)) bat(); ->bat : Symbol(J.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 13, 13)) +>bat : Symbol(J.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 12, 13)) } class D implements I, J { ->D : Symbol(D, Decl(declFileForClassWithMultipleBaseClasses.ts, 15, 1)) ->I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 7, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 23, 1)) ->J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 11, 1)) +>D : Symbol(D, Decl(declFileForClassWithMultipleBaseClasses.ts, 14, 1)) +>I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 6, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 22, 1)) +>J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 10, 1)) baz() { } ->baz : Symbol(D.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 18, 25)) +>baz : Symbol(D.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 17, 25)) bat() { } ->bat : Symbol(D.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 19, 13)) +>bat : Symbol(D.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 18, 13)) foo() { } ->foo : Symbol(D.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 20, 13)) +>foo : Symbol(D.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 19, 13)) bar() { } ->bar : Symbol(D.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 21, 13)) +>bar : Symbol(D.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 20, 13)) } interface I extends A, B { ->I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 7, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 23, 1)) +>I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 6, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 22, 1)) >A : Symbol(A, Decl(declFileForClassWithMultipleBaseClasses.ts, 0, 0)) ->B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 3, 1)) +>B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 2, 1)) } diff --git a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types index 0f7861d8b8e..b2438e13159 100644 --- a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types +++ b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForClassWithMultipleBaseClasses.ts === - class A { >A : A diff --git a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js index 2c0e89fe6db..cff015a8b29 100644 --- a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js +++ b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js @@ -1,5 +1,4 @@ //// [declFileForClassWithPrivateOverloadedFunction.ts] - class C { private foo(x: number); private foo(x: string); diff --git a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols index 69bf3db2cb3..e0aff6e6c46 100644 --- a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols +++ b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/declFileForClassWithPrivateOverloadedFunction.ts === - class C { >C : Symbol(C, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 0)) private foo(x: number); ->foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 27)) ->x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 16)) +>foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27)) +>x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 16)) private foo(x: string); ->foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 27)) ->x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 16)) +>foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27)) +>x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 16)) private foo(x: any) { } ->foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 27)) ->x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 4, 16)) +>foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27)) +>x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 16)) } diff --git a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types index efdfde4574c..4e0197be903 100644 --- a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types +++ b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForClassWithPrivateOverloadedFunction.ts === - class C { >C : C diff --git a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js index 9bdd0fc09a7..e97ee76d510 100644 --- a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js +++ b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js @@ -1,5 +1,4 @@ //// [declFileForFunctionTypeAsTypeParameter.ts] - class X { } class C extends X<() => number> { diff --git a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols index 329363ec364..f153fef40a0 100644 --- a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols +++ b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/declFileForFunctionTypeAsTypeParameter.ts === - class X { >X : Symbol(X, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 0)) ->T : Symbol(T, Decl(declFileForFunctionTypeAsTypeParameter.ts, 1, 8)) +>T : Symbol(T, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 8)) } class C extends X<() => number> { ->C : Symbol(C, Decl(declFileForFunctionTypeAsTypeParameter.ts, 2, 1)) +>C : Symbol(C, Decl(declFileForFunctionTypeAsTypeParameter.ts, 1, 1)) >X : Symbol(X, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 0)) } interface I extends X<() => number> { ->I : Symbol(I, Decl(declFileForFunctionTypeAsTypeParameter.ts, 4, 1)) +>I : Symbol(I, Decl(declFileForFunctionTypeAsTypeParameter.ts, 3, 1)) >X : Symbol(X, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 0)) } diff --git a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types index ba203e39aab..2bd1c039bf7 100644 --- a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types +++ b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForFunctionTypeAsTypeParameter.ts === - class X { >X : X >T : T diff --git a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js index 6010e632966..4412c4a925b 100644 --- a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js +++ b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js @@ -1,5 +1,4 @@ //// [declFileForInterfaceWithOptionalFunction.ts] - interface I { foo? (x?); foo2? (x?: number): number; diff --git a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols index a6a3e272c94..d434c9d08a1 100644 --- a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols +++ b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/declFileForInterfaceWithOptionalFunction.ts === - interface I { >I : Symbol(I, Decl(declFileForInterfaceWithOptionalFunction.ts, 0, 0)) foo? (x?); ->foo : Symbol(I.foo, Decl(declFileForInterfaceWithOptionalFunction.ts, 1, 13)) ->x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 2, 10)) +>foo : Symbol(I.foo, Decl(declFileForInterfaceWithOptionalFunction.ts, 0, 13)) +>x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 1, 10)) foo2? (x?: number): number; ->foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithOptionalFunction.ts, 2, 14)) ->x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 3, 11)) +>foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithOptionalFunction.ts, 1, 14)) +>x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 2, 11)) } diff --git a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types index fab33c939cf..e653802dd75 100644 --- a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types +++ b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForInterfaceWithOptionalFunction.ts === - interface I { >I : I diff --git a/tests/baselines/reference/declFileForInterfaceWithRestParams.js b/tests/baselines/reference/declFileForInterfaceWithRestParams.js index 8979f7df6da..2bc78db7003 100644 --- a/tests/baselines/reference/declFileForInterfaceWithRestParams.js +++ b/tests/baselines/reference/declFileForInterfaceWithRestParams.js @@ -1,5 +1,4 @@ //// [declFileForInterfaceWithRestParams.ts] - interface I { foo(...x): typeof x; foo2(a: number, ...x): typeof x; diff --git a/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols b/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols index bccb096eb6c..c820a7baa83 100644 --- a/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols +++ b/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declFileForInterfaceWithRestParams.ts === - interface I { >I : Symbol(I, Decl(declFileForInterfaceWithRestParams.ts, 0, 0)) foo(...x): typeof x; ->foo : Symbol(I.foo, Decl(declFileForInterfaceWithRestParams.ts, 1, 13)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 8)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 8)) +>foo : Symbol(I.foo, Decl(declFileForInterfaceWithRestParams.ts, 0, 13)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 1, 8)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 1, 8)) foo2(a: number, ...x): typeof x; ->foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithRestParams.ts, 2, 24)) ->a : Symbol(a, Decl(declFileForInterfaceWithRestParams.ts, 3, 9)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) +>foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithRestParams.ts, 1, 24)) +>a : Symbol(a, Decl(declFileForInterfaceWithRestParams.ts, 2, 9)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 19)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 19)) foo3(b: string, ...x: string[]): typeof x; ->foo3 : Symbol(I.foo3, Decl(declFileForInterfaceWithRestParams.ts, 3, 36)) ->b : Symbol(b, Decl(declFileForInterfaceWithRestParams.ts, 4, 9)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 4, 19)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 4, 19)) +>foo3 : Symbol(I.foo3, Decl(declFileForInterfaceWithRestParams.ts, 2, 36)) +>b : Symbol(b, Decl(declFileForInterfaceWithRestParams.ts, 3, 9)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) } diff --git a/tests/baselines/reference/declFileForInterfaceWithRestParams.types b/tests/baselines/reference/declFileForInterfaceWithRestParams.types index 817e118fb6c..7ea4eb598f5 100644 --- a/tests/baselines/reference/declFileForInterfaceWithRestParams.types +++ b/tests/baselines/reference/declFileForInterfaceWithRestParams.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForInterfaceWithRestParams.ts === - interface I { >I : I diff --git a/tests/baselines/reference/declFileForTypeParameters.js b/tests/baselines/reference/declFileForTypeParameters.js index 3fbac683ef9..4000e6301eb 100644 --- a/tests/baselines/reference/declFileForTypeParameters.js +++ b/tests/baselines/reference/declFileForTypeParameters.js @@ -1,5 +1,4 @@ //// [declFileForTypeParameters.ts] - class C { x: T; foo(a: T): T { diff --git a/tests/baselines/reference/declFileForTypeParameters.symbols b/tests/baselines/reference/declFileForTypeParameters.symbols index 8838c3cdd05..626421881c2 100644 --- a/tests/baselines/reference/declFileForTypeParameters.symbols +++ b/tests/baselines/reference/declFileForTypeParameters.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declFileForTypeParameters.ts === - class C { >C : Symbol(C, Decl(declFileForTypeParameters.ts, 0, 0)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) x: T; ->x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 1, 12)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) +>x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 0, 12)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) foo(a: T): T { ->foo : Symbol(C.foo, Decl(declFileForTypeParameters.ts, 2, 9)) ->a : Symbol(a, Decl(declFileForTypeParameters.ts, 3, 8)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) +>foo : Symbol(C.foo, Decl(declFileForTypeParameters.ts, 1, 9)) +>a : Symbol(a, Decl(declFileForTypeParameters.ts, 2, 8)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) return this.x; ->this.x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 1, 12)) +>this.x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 0, 12)) >this : Symbol(C, Decl(declFileForTypeParameters.ts, 0, 0)) ->x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 1, 12)) +>x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 0, 12)) } } diff --git a/tests/baselines/reference/declFileForTypeParameters.types b/tests/baselines/reference/declFileForTypeParameters.types index fe69da2cd0f..e0cb47d8375 100644 --- a/tests/baselines/reference/declFileForTypeParameters.types +++ b/tests/baselines/reference/declFileForTypeParameters.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForTypeParameters.ts === - class C { >C : C >T : T diff --git a/tests/baselines/reference/declFileForVarList.js b/tests/baselines/reference/declFileForVarList.js index bb481017e3e..0ccd51d2f71 100644 --- a/tests/baselines/reference/declFileForVarList.js +++ b/tests/baselines/reference/declFileForVarList.js @@ -1,5 +1,4 @@ //// [declFileForVarList.ts] - var x, y, z = 1; var x1 = 1, y2 = 2, z2 = 3; diff --git a/tests/baselines/reference/declFileForVarList.symbols b/tests/baselines/reference/declFileForVarList.symbols index 9e2fdd3ac6b..1e6e14927b2 100644 --- a/tests/baselines/reference/declFileForVarList.symbols +++ b/tests/baselines/reference/declFileForVarList.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/declFileForVarList.ts === - var x, y, z = 1; ->x : Symbol(x, Decl(declFileForVarList.ts, 1, 3)) ->y : Symbol(y, Decl(declFileForVarList.ts, 1, 6)) ->z : Symbol(z, Decl(declFileForVarList.ts, 1, 9)) +>x : Symbol(x, Decl(declFileForVarList.ts, 0, 3)) +>y : Symbol(y, Decl(declFileForVarList.ts, 0, 6)) +>z : Symbol(z, Decl(declFileForVarList.ts, 0, 9)) var x1 = 1, y2 = 2, z2 = 3; ->x1 : Symbol(x1, Decl(declFileForVarList.ts, 2, 3)) ->y2 : Symbol(y2, Decl(declFileForVarList.ts, 2, 11)) ->z2 : Symbol(z2, Decl(declFileForVarList.ts, 2, 19)) +>x1 : Symbol(x1, Decl(declFileForVarList.ts, 1, 3)) +>y2 : Symbol(y2, Decl(declFileForVarList.ts, 1, 11)) +>z2 : Symbol(z2, Decl(declFileForVarList.ts, 1, 19)) diff --git a/tests/baselines/reference/declFileForVarList.types b/tests/baselines/reference/declFileForVarList.types index d4c401d2383..89514b6576c 100644 --- a/tests/baselines/reference/declFileForVarList.types +++ b/tests/baselines/reference/declFileForVarList.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForVarList.ts === - var x, y, z = 1; >x : any >y : any diff --git a/tests/baselines/reference/declFileFunctions.js b/tests/baselines/reference/declFileFunctions.js index f62b7772b41..68ac66200a6 100644 --- a/tests/baselines/reference/declFileFunctions.js +++ b/tests/baselines/reference/declFileFunctions.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileFunctions.ts] //// //// [declFileFunctions_0.ts] - /** This comment should appear for foo*/ export function foo() { } diff --git a/tests/baselines/reference/declFileFunctions.symbols b/tests/baselines/reference/declFileFunctions.symbols index 9ee1a3603bd..6ec16c3399e 100644 --- a/tests/baselines/reference/declFileFunctions.symbols +++ b/tests/baselines/reference/declFileFunctions.symbols @@ -1,139 +1,138 @@ === tests/cases/compiler/declFileFunctions_0.ts === - /** This comment should appear for foo*/ export function foo() { >foo : Symbol(foo, Decl(declFileFunctions_0.ts, 0, 0)) } /** This is comment for function signature*/ export function fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(fooWithParameters, Decl(declFileFunctions_0.ts, 3, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 5, 34)) +>fooWithParameters : Symbol(fooWithParameters, Decl(declFileFunctions_0.ts, 2, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 4, 34)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileFunctions_0.ts, 5, 73)) +>b : Symbol(b, Decl(declFileFunctions_0.ts, 4, 73)) var d = a; ->d : Symbol(d, Decl(declFileFunctions_0.ts, 8, 7)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 5, 34)) +>d : Symbol(d, Decl(declFileFunctions_0.ts, 7, 7)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 4, 34)) } export function fooWithRestParameters(a: string, ...rests: string[]) { ->fooWithRestParameters : Symbol(fooWithRestParameters, Decl(declFileFunctions_0.ts, 9, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 10, 38)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 10, 48)) +>fooWithRestParameters : Symbol(fooWithRestParameters, Decl(declFileFunctions_0.ts, 8, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 9, 38)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 9, 48)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileFunctions_0.ts, 10, 38)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 9, 38)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 10, 48)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 9, 48)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } export function fooWithOverloads(a: string): string; ->fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 12, 1), Decl(declFileFunctions_0.ts, 14, 52), Decl(declFileFunctions_0.ts, 15, 52)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 14, 33)) +>fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 11, 1), Decl(declFileFunctions_0.ts, 13, 52), Decl(declFileFunctions_0.ts, 14, 52)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 13, 33)) export function fooWithOverloads(a: number): number; ->fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 12, 1), Decl(declFileFunctions_0.ts, 14, 52), Decl(declFileFunctions_0.ts, 15, 52)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 15, 33)) +>fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 11, 1), Decl(declFileFunctions_0.ts, 13, 52), Decl(declFileFunctions_0.ts, 14, 52)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 14, 33)) export function fooWithOverloads(a: any): any { ->fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 12, 1), Decl(declFileFunctions_0.ts, 14, 52), Decl(declFileFunctions_0.ts, 15, 52)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 16, 33)) +>fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 11, 1), Decl(declFileFunctions_0.ts, 13, 52), Decl(declFileFunctions_0.ts, 14, 52)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 15, 33)) return a; ->a : Symbol(a, Decl(declFileFunctions_0.ts, 16, 33)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 15, 33)) } export function fooWithSingleOverload(a: string): string; ->fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 18, 1), Decl(declFileFunctions_0.ts, 20, 57)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 20, 38)) +>fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 17, 1), Decl(declFileFunctions_0.ts, 19, 57)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 19, 38)) export function fooWithSingleOverload(a: any) { ->fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 18, 1), Decl(declFileFunctions_0.ts, 20, 57)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 21, 38)) +>fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 17, 1), Decl(declFileFunctions_0.ts, 19, 57)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 20, 38)) return a; ->a : Symbol(a, Decl(declFileFunctions_0.ts, 21, 38)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 20, 38)) } export function fooWithTypePredicate(a: any): a is number { ->fooWithTypePredicate : Symbol(fooWithTypePredicate, Decl(declFileFunctions_0.ts, 23, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 25, 37)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 25, 37)) +>fooWithTypePredicate : Symbol(fooWithTypePredicate, Decl(declFileFunctions_0.ts, 22, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 24, 37)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 24, 37)) return true; } export function fooWithTypePredicateAndMulitpleParams(a: any, b: any, c: any): a is number { ->fooWithTypePredicateAndMulitpleParams : Symbol(fooWithTypePredicateAndMulitpleParams, Decl(declFileFunctions_0.ts, 27, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 28, 54)) ->b : Symbol(b, Decl(declFileFunctions_0.ts, 28, 61)) ->c : Symbol(c, Decl(declFileFunctions_0.ts, 28, 69)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 28, 54)) +>fooWithTypePredicateAndMulitpleParams : Symbol(fooWithTypePredicateAndMulitpleParams, Decl(declFileFunctions_0.ts, 26, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 27, 54)) +>b : Symbol(b, Decl(declFileFunctions_0.ts, 27, 61)) +>c : Symbol(c, Decl(declFileFunctions_0.ts, 27, 69)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 27, 54)) return true; } export function fooWithTypeTypePredicateAndGeneric(a: any): a is T { ->fooWithTypeTypePredicateAndGeneric : Symbol(fooWithTypeTypePredicateAndGeneric, Decl(declFileFunctions_0.ts, 30, 1)) ->T : Symbol(T, Decl(declFileFunctions_0.ts, 31, 51)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 31, 54)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 31, 54)) ->T : Symbol(T, Decl(declFileFunctions_0.ts, 31, 51)) +>fooWithTypeTypePredicateAndGeneric : Symbol(fooWithTypeTypePredicateAndGeneric, Decl(declFileFunctions_0.ts, 29, 1)) +>T : Symbol(T, Decl(declFileFunctions_0.ts, 30, 51)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 30, 54)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 30, 54)) +>T : Symbol(T, Decl(declFileFunctions_0.ts, 30, 51)) return true; } export function fooWithTypeTypePredicateAndRestParam(a: any, ...rest): a is number { ->fooWithTypeTypePredicateAndRestParam : Symbol(fooWithTypeTypePredicateAndRestParam, Decl(declFileFunctions_0.ts, 33, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 34, 53)) ->rest : Symbol(rest, Decl(declFileFunctions_0.ts, 34, 60)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 34, 53)) +>fooWithTypeTypePredicateAndRestParam : Symbol(fooWithTypeTypePredicateAndRestParam, Decl(declFileFunctions_0.ts, 32, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 33, 53)) +>rest : Symbol(rest, Decl(declFileFunctions_0.ts, 33, 60)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 33, 53)) return true; } /** This comment should appear for nonExportedFoo*/ function nonExportedFoo() { ->nonExportedFoo : Symbol(nonExportedFoo, Decl(declFileFunctions_0.ts, 36, 1)) +>nonExportedFoo : Symbol(nonExportedFoo, Decl(declFileFunctions_0.ts, 35, 1)) } /** This is comment for function signature*/ function nonExportedFooWithParameters(/** this is comment about a*/a: string, ->nonExportedFooWithParameters : Symbol(nonExportedFooWithParameters, Decl(declFileFunctions_0.ts, 40, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 42, 38)) +>nonExportedFooWithParameters : Symbol(nonExportedFooWithParameters, Decl(declFileFunctions_0.ts, 39, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 41, 38)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileFunctions_0.ts, 42, 77)) +>b : Symbol(b, Decl(declFileFunctions_0.ts, 41, 77)) var d = a; ->d : Symbol(d, Decl(declFileFunctions_0.ts, 45, 7)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 42, 38)) +>d : Symbol(d, Decl(declFileFunctions_0.ts, 44, 7)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 41, 38)) } function nonExportedFooWithRestParameters(a: string, ...rests: string[]) { ->nonExportedFooWithRestParameters : Symbol(nonExportedFooWithRestParameters, Decl(declFileFunctions_0.ts, 46, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 47, 42)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 47, 52)) +>nonExportedFooWithRestParameters : Symbol(nonExportedFooWithRestParameters, Decl(declFileFunctions_0.ts, 45, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 46, 42)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 46, 52)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileFunctions_0.ts, 47, 42)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 46, 42)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 47, 52)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 46, 52)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } function nonExportedFooWithOverloads(a: string): string; ->nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 49, 1), Decl(declFileFunctions_0.ts, 51, 56), Decl(declFileFunctions_0.ts, 52, 56)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 51, 37)) +>nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 48, 1), Decl(declFileFunctions_0.ts, 50, 56), Decl(declFileFunctions_0.ts, 51, 56)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 50, 37)) function nonExportedFooWithOverloads(a: number): number; ->nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 49, 1), Decl(declFileFunctions_0.ts, 51, 56), Decl(declFileFunctions_0.ts, 52, 56)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 52, 37)) +>nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 48, 1), Decl(declFileFunctions_0.ts, 50, 56), Decl(declFileFunctions_0.ts, 51, 56)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 51, 37)) function nonExportedFooWithOverloads(a: any): any { ->nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 49, 1), Decl(declFileFunctions_0.ts, 51, 56), Decl(declFileFunctions_0.ts, 52, 56)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 53, 37)) +>nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 48, 1), Decl(declFileFunctions_0.ts, 50, 56), Decl(declFileFunctions_0.ts, 51, 56)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 52, 37)) return a; ->a : Symbol(a, Decl(declFileFunctions_0.ts, 53, 37)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 52, 37)) } === tests/cases/compiler/declFileFunctions_1.ts === diff --git a/tests/baselines/reference/declFileFunctions.types b/tests/baselines/reference/declFileFunctions.types index ee35577ce3e..c5bb89d38d3 100644 --- a/tests/baselines/reference/declFileFunctions.types +++ b/tests/baselines/reference/declFileFunctions.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileFunctions_0.ts === - /** This comment should appear for foo*/ export function foo() { >foo : () => void diff --git a/tests/baselines/reference/declFileGenericType2.js b/tests/baselines/reference/declFileGenericType2.js index 1c6f2002da2..5abf1a74a02 100644 --- a/tests/baselines/reference/declFileGenericType2.js +++ b/tests/baselines/reference/declFileGenericType2.js @@ -1,5 +1,4 @@ //// [declFileGenericType2.ts] - declare module templa.mvc { interface IModel { } diff --git a/tests/baselines/reference/declFileGenericType2.symbols b/tests/baselines/reference/declFileGenericType2.symbols index 60ced2992d4..43b61753a88 100644 --- a/tests/baselines/reference/declFileGenericType2.symbols +++ b/tests/baselines/reference/declFileGenericType2.symbols @@ -1,146 +1,145 @@ === tests/cases/compiler/declFileGenericType2.ts === - declare module templa.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) interface IModel { ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) } } declare module templa.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) interface IController { ->IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 6, 26)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 5, 26)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) } } declare module templa.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) class AbstractController implements mvc.IController { ->AbstractController : Symbol(AbstractController, Decl(declFileGenericType2.ts, 9, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 10, 29)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) ->mvc.IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 10, 29)) +>AbstractController : Symbol(AbstractController, Decl(declFileGenericType2.ts, 8, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 9, 29)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) +>mvc.IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 9, 29)) } } declare module templa.mvc.composite { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->composite : Symbol(composite, Decl(declFileGenericType2.ts, 13, 26)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>composite : Symbol(composite, Decl(declFileGenericType2.ts, 12, 26)) interface ICompositeControllerModel extends mvc.IModel { ->ICompositeControllerModel : Symbol(ICompositeControllerModel, Decl(declFileGenericType2.ts, 13, 37)) ->mvc.IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>ICompositeControllerModel : Symbol(ICompositeControllerModel, Decl(declFileGenericType2.ts, 12, 37)) +>mvc.IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) getControllers(): mvc.IController[]; ->getControllers : Symbol(ICompositeControllerModel.getControllers, Decl(declFileGenericType2.ts, 14, 60)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>getControllers : Symbol(ICompositeControllerModel.getControllers, Decl(declFileGenericType2.ts, 13, 60)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) } } module templa.dom.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) export interface IElementController extends templa.mvc.IController { ->IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 18, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 19, 40)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 1, 27)) ->templa.mvc.IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 5, 27)) ->templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 5, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 19, 40)) +>IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 17, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 18, 40)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 0, 27)) +>templa.mvc.IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 4, 27)) +>templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 4, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 18, 40)) } } // Module module templa.dom.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) export class AbstractElementController extends templa.mvc.AbstractController implements IElementController { ->AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 25, 43)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 1, 27)) ->templa.mvc.AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 9, 27)) ->templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 9, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 25, 43)) ->IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 18, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 25, 43)) +>AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 24, 43)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 0, 27)) +>templa.mvc.AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 8, 27)) +>templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 8, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 24, 43)) +>IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 17, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 24, 43)) constructor() { super(); ->super : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 9, 27)) +>super : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 8, 27)) } } } // Module module templa.dom.mvc.composite { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) ->composite : Symbol(composite, Decl(declFileGenericType2.ts, 32, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) +>composite : Symbol(composite, Decl(declFileGenericType2.ts, 31, 22)) export class AbstractCompositeElementController extends templa.dom.mvc.AbstractElementController { ->AbstractCompositeElementController : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 32, 33)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 33, 52)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->composite : Symbol(templa.mvc.composite, Decl(declFileGenericType2.ts, 13, 26)) ->ICompositeControllerModel : Symbol(templa.mvc.composite.ICompositeControllerModel, Decl(declFileGenericType2.ts, 13, 37)) ->templa.dom.mvc.AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) ->templa.dom.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) ->templa.dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) ->AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 33, 52)) +>AbstractCompositeElementController : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 31, 33)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 32, 52)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>composite : Symbol(templa.mvc.composite, Decl(declFileGenericType2.ts, 12, 26)) +>ICompositeControllerModel : Symbol(templa.mvc.composite.ICompositeControllerModel, Decl(declFileGenericType2.ts, 12, 37)) +>templa.dom.mvc.AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) +>templa.dom.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) +>templa.dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) +>AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 32, 52)) public _controllers: templa.mvc.IController[]; ->_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 33, 179)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 5, 27)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 1, 27)) +>_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 32, 179)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 4, 27)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 0, 27)) constructor() { super(); ->super : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) +>super : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) this._controllers = []; ->this._controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 33, 179)) ->this : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 32, 33)) ->_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 33, 179)) +>this._controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 32, 179)) +>this : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 31, 33)) +>_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 32, 179)) } } } diff --git a/tests/baselines/reference/declFileGenericType2.types b/tests/baselines/reference/declFileGenericType2.types index c2a43db1921..56e7dc2471a 100644 --- a/tests/baselines/reference/declFileGenericType2.types +++ b/tests/baselines/reference/declFileGenericType2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileGenericType2.ts === - declare module templa.mvc { >templa : typeof templa >mvc : typeof mvc diff --git a/tests/baselines/reference/declFileImportModuleWithExportAssignment.js b/tests/baselines/reference/declFileImportModuleWithExportAssignment.js index 110539774df..5215d3d1431 100644 --- a/tests/baselines/reference/declFileImportModuleWithExportAssignment.js +++ b/tests/baselines/reference/declFileImportModuleWithExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileImportModuleWithExportAssignment.ts] //// //// [declFileImportModuleWithExportAssignment_0.ts] - module m2 { export interface connectModule { (res, req, next): void; diff --git a/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols b/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols index 1681dfa2782..eb08bd48a4c 100644 --- a/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols +++ b/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols @@ -8,56 +8,55 @@ export var a = a1; >a1 : Symbol(a1, Decl(declFileImportModuleWithExportAssignment_1.ts, 0, 0)) a.test1(null, null, null); ->a.test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 25)) +>a.test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 25)) >a : Symbol(a, Decl(declFileImportModuleWithExportAssignment_1.ts, 2, 10)) ->test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 25)) +>test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 25)) === tests/cases/compiler/declFileImportModuleWithExportAssignment_0.ts === - module m2 { ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) export interface connectModule { ->connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) +>connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) (res, req, next): void; ->res : Symbol(res, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 9)) ->req : Symbol(req, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 13)) ->next : Symbol(next, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 18)) +>res : Symbol(res, Decl(declFileImportModuleWithExportAssignment_0.ts, 2, 9)) +>req : Symbol(req, Decl(declFileImportModuleWithExportAssignment_0.ts, 2, 13)) +>next : Symbol(next, Decl(declFileImportModuleWithExportAssignment_0.ts, 2, 18)) } export interface connectExport { ->connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 5)) +>connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 5)) use: (mod: connectModule) => connectExport; ->use : Symbol(connectExport.use, Decl(declFileImportModuleWithExportAssignment_0.ts, 5, 36)) ->mod : Symbol(mod, Decl(declFileImportModuleWithExportAssignment_0.ts, 6, 14)) ->connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) ->connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 5)) +>use : Symbol(connectExport.use, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 36)) +>mod : Symbol(mod, Decl(declFileImportModuleWithExportAssignment_0.ts, 5, 14)) +>connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) +>connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 5)) listen: (port: number) => void; ->listen : Symbol(connectExport.listen, Decl(declFileImportModuleWithExportAssignment_0.ts, 6, 51)) ->port : Symbol(port, Decl(declFileImportModuleWithExportAssignment_0.ts, 7, 17)) +>listen : Symbol(connectExport.listen, Decl(declFileImportModuleWithExportAssignment_0.ts, 5, 51)) +>port : Symbol(port, Decl(declFileImportModuleWithExportAssignment_0.ts, 6, 17)) } } var m2: { ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) (): m2.connectExport; ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) ->connectExport : Symbol(m2.connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 5)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) +>connectExport : Symbol(m2.connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 5)) test1: m2.connectModule; ->test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 25)) ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) ->connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) +>test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 25)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) +>connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) test2(): m2.connectModule; ->test2 : Symbol(test2, Decl(declFileImportModuleWithExportAssignment_0.ts, 13, 28)) ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) ->connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) +>test2 : Symbol(test2, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 28)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) +>connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) }; export = m2; ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) diff --git a/tests/baselines/reference/declFileImportModuleWithExportAssignment.types b/tests/baselines/reference/declFileImportModuleWithExportAssignment.types index 123b7b56d4f..a1bec1e3f52 100644 --- a/tests/baselines/reference/declFileImportModuleWithExportAssignment.types +++ b/tests/baselines/reference/declFileImportModuleWithExportAssignment.types @@ -17,7 +17,6 @@ a.test1(null, null, null); >null : null === tests/cases/compiler/declFileImportModuleWithExportAssignment_0.ts === - module m2 { >m2 : { (): connectExport; test1: connectModule; test2(): connectModule; } diff --git a/tests/baselines/reference/declFileIndexSignatures.js b/tests/baselines/reference/declFileIndexSignatures.js index b7b2698b11b..0282816e9d8 100644 --- a/tests/baselines/reference/declFileIndexSignatures.js +++ b/tests/baselines/reference/declFileIndexSignatures.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileIndexSignatures.ts] //// //// [declFileIndexSignatures_0.ts] - export interface IStringIndexSignature { [s: string]: string; } diff --git a/tests/baselines/reference/declFileIndexSignatures.symbols b/tests/baselines/reference/declFileIndexSignatures.symbols index e89cfc79b0d..c04de687b03 100644 --- a/tests/baselines/reference/declFileIndexSignatures.symbols +++ b/tests/baselines/reference/declFileIndexSignatures.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/declFileIndexSignatures_0.ts === - export interface IStringIndexSignature { >IStringIndexSignature : Symbol(IStringIndexSignature, Decl(declFileIndexSignatures_0.ts, 0, 0)) [s: string]: string; ->s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 2, 5)) +>s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 1, 5)) } export interface INumberIndexSignature { ->INumberIndexSignature : Symbol(INumberIndexSignature, Decl(declFileIndexSignatures_0.ts, 3, 1)) +>INumberIndexSignature : Symbol(INumberIndexSignature, Decl(declFileIndexSignatures_0.ts, 2, 1)) [n: number]: number; ->n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 5, 5)) +>n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 4, 5)) } export interface IBothIndexSignature { ->IBothIndexSignature : Symbol(IBothIndexSignature, Decl(declFileIndexSignatures_0.ts, 6, 1)) +>IBothIndexSignature : Symbol(IBothIndexSignature, Decl(declFileIndexSignatures_0.ts, 5, 1)) [s: string]: any; ->s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 9, 5)) +>s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 8, 5)) [n: number]: number; ->n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 10, 5)) +>n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 9, 5)) } export interface IIndexSignatureWithTypeParameter { ->IIndexSignatureWithTypeParameter : Symbol(IIndexSignatureWithTypeParameter, Decl(declFileIndexSignatures_0.ts, 11, 1)) ->T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 13, 50)) +>IIndexSignatureWithTypeParameter : Symbol(IIndexSignatureWithTypeParameter, Decl(declFileIndexSignatures_0.ts, 10, 1)) +>T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 12, 50)) [a: string]: T; ->a : Symbol(a, Decl(declFileIndexSignatures_0.ts, 14, 5)) ->T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 13, 50)) +>a : Symbol(a, Decl(declFileIndexSignatures_0.ts, 13, 5)) +>T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 12, 50)) } === tests/cases/compiler/declFileIndexSignatures_1.ts === diff --git a/tests/baselines/reference/declFileIndexSignatures.types b/tests/baselines/reference/declFileIndexSignatures.types index c971fb4aeb0..28822a4bfd1 100644 --- a/tests/baselines/reference/declFileIndexSignatures.types +++ b/tests/baselines/reference/declFileIndexSignatures.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileIndexSignatures_0.ts === - export interface IStringIndexSignature { >IStringIndexSignature : IStringIndexSignature diff --git a/tests/baselines/reference/declFileMethods.js b/tests/baselines/reference/declFileMethods.js index 61e2bfab700..cc6d796e5cf 100644 --- a/tests/baselines/reference/declFileMethods.js +++ b/tests/baselines/reference/declFileMethods.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileMethods.ts] //// //// [declFileMethods_0.ts] - export class c1 { /** This comment should appear for foo*/ public foo() { diff --git a/tests/baselines/reference/declFileMethods.symbols b/tests/baselines/reference/declFileMethods.symbols index 723065c62e4..4acf63eff08 100644 --- a/tests/baselines/reference/declFileMethods.symbols +++ b/tests/baselines/reference/declFileMethods.symbols @@ -1,217 +1,216 @@ === tests/cases/compiler/declFileMethods_0.ts === - export class c1 { >c1 : Symbol(c1, Decl(declFileMethods_0.ts, 0, 0)) /** This comment should appear for foo*/ public foo() { ->foo : Symbol(c1.foo, Decl(declFileMethods_0.ts, 1, 17)) +>foo : Symbol(c1.foo, Decl(declFileMethods_0.ts, 0, 17)) } /** This is comment for function signature*/ public fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(c1.fooWithParameters, Decl(declFileMethods_0.ts, 4, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 6, 29)) +>fooWithParameters : Symbol(c1.fooWithParameters, Decl(declFileMethods_0.ts, 3, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 5, 29)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 6, 68)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 5, 68)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 9, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 6, 29)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 8, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 5, 29)) } public fooWithRestParameters(a: string, ...rests: string[]) { ->fooWithRestParameters : Symbol(c1.fooWithRestParameters, Decl(declFileMethods_0.ts, 10, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 11, 33)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 11, 43)) +>fooWithRestParameters : Symbol(c1.fooWithRestParameters, Decl(declFileMethods_0.ts, 9, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 10, 33)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 10, 43)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 11, 33)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 10, 33)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 11, 43)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 10, 43)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } public fooWithOverloads(a: string): string; ->fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 15, 28)) +>fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 12, 5), Decl(declFileMethods_0.ts, 14, 47), Decl(declFileMethods_0.ts, 15, 47)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 14, 28)) public fooWithOverloads(a: number): number; ->fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 16, 28)) +>fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 12, 5), Decl(declFileMethods_0.ts, 14, 47), Decl(declFileMethods_0.ts, 15, 47)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 15, 28)) public fooWithOverloads(a: any): any { ->fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 17, 28)) +>fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 12, 5), Decl(declFileMethods_0.ts, 14, 47), Decl(declFileMethods_0.ts, 15, 47)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 16, 28)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 17, 28)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 16, 28)) } /** This comment should appear for privateFoo*/ private privateFoo() { ->privateFoo : Symbol(c1.privateFoo, Decl(declFileMethods_0.ts, 19, 5)) +>privateFoo : Symbol(c1.privateFoo, Decl(declFileMethods_0.ts, 18, 5)) } /** This is comment for function signature*/ private privateFooWithParameters(/** this is comment about a*/a: string, ->privateFooWithParameters : Symbol(c1.privateFooWithParameters, Decl(declFileMethods_0.ts, 24, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 26, 37)) +>privateFooWithParameters : Symbol(c1.privateFooWithParameters, Decl(declFileMethods_0.ts, 23, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 25, 37)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 26, 76)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 25, 76)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 29, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 26, 37)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 28, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 25, 37)) } private privateFooWithRestParameters(a: string, ...rests: string[]) { ->privateFooWithRestParameters : Symbol(c1.privateFooWithRestParameters, Decl(declFileMethods_0.ts, 30, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 31, 41)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 31, 51)) +>privateFooWithRestParameters : Symbol(c1.privateFooWithRestParameters, Decl(declFileMethods_0.ts, 29, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 30, 41)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 30, 51)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 31, 41)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 30, 41)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 31, 51)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 30, 51)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private privateFooWithOverloads(a: string): string; ->privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 34, 36)) +>privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 32, 5), Decl(declFileMethods_0.ts, 33, 55), Decl(declFileMethods_0.ts, 34, 55)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 33, 36)) private privateFooWithOverloads(a: number): number; ->privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 35, 36)) +>privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 32, 5), Decl(declFileMethods_0.ts, 33, 55), Decl(declFileMethods_0.ts, 34, 55)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 34, 36)) private privateFooWithOverloads(a: any): any { ->privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 36, 36)) +>privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 32, 5), Decl(declFileMethods_0.ts, 33, 55), Decl(declFileMethods_0.ts, 34, 55)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 35, 36)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 36, 36)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 35, 36)) } /** This comment should appear for static foo*/ static staticFoo() { ->staticFoo : Symbol(c1.staticFoo, Decl(declFileMethods_0.ts, 38, 5)) +>staticFoo : Symbol(c1.staticFoo, Decl(declFileMethods_0.ts, 37, 5)) } /** This is comment for function signature*/ static staticFooWithParameters(/** this is comment about a*/a: string, ->staticFooWithParameters : Symbol(c1.staticFooWithParameters, Decl(declFileMethods_0.ts, 43, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 45, 35)) +>staticFooWithParameters : Symbol(c1.staticFooWithParameters, Decl(declFileMethods_0.ts, 42, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 44, 35)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 45, 74)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 44, 74)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 48, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 45, 35)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 47, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 44, 35)) } static staticFooWithRestParameters(a: string, ...rests: string[]) { ->staticFooWithRestParameters : Symbol(c1.staticFooWithRestParameters, Decl(declFileMethods_0.ts, 49, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 50, 39)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 50, 49)) +>staticFooWithRestParameters : Symbol(c1.staticFooWithRestParameters, Decl(declFileMethods_0.ts, 48, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 49, 39)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 49, 49)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 50, 39)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 49, 39)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 50, 49)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 49, 49)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } static staticFooWithOverloads(a: string): string; ->staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 53, 34)) +>staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 51, 5), Decl(declFileMethods_0.ts, 52, 53), Decl(declFileMethods_0.ts, 53, 53)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 52, 34)) static staticFooWithOverloads(a: number): number; ->staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 54, 34)) +>staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 51, 5), Decl(declFileMethods_0.ts, 52, 53), Decl(declFileMethods_0.ts, 53, 53)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 53, 34)) static staticFooWithOverloads(a: any): any { ->staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 55, 34)) +>staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 51, 5), Decl(declFileMethods_0.ts, 52, 53), Decl(declFileMethods_0.ts, 53, 53)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 54, 34)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 55, 34)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 54, 34)) } /** This comment should appear for privateStaticFoo*/ private static privateStaticFoo() { ->privateStaticFoo : Symbol(c1.privateStaticFoo, Decl(declFileMethods_0.ts, 57, 5)) +>privateStaticFoo : Symbol(c1.privateStaticFoo, Decl(declFileMethods_0.ts, 56, 5)) } /** This is comment for function signature*/ private static privateStaticFooWithParameters(/** this is comment about a*/a: string, ->privateStaticFooWithParameters : Symbol(c1.privateStaticFooWithParameters, Decl(declFileMethods_0.ts, 62, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 64, 50)) +>privateStaticFooWithParameters : Symbol(c1.privateStaticFooWithParameters, Decl(declFileMethods_0.ts, 61, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 63, 50)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 64, 89)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 63, 89)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 67, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 64, 50)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 66, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 63, 50)) } private static privateStaticFooWithRestParameters(a: string, ...rests: string[]) { ->privateStaticFooWithRestParameters : Symbol(c1.privateStaticFooWithRestParameters, Decl(declFileMethods_0.ts, 68, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 69, 54)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 69, 64)) +>privateStaticFooWithRestParameters : Symbol(c1.privateStaticFooWithRestParameters, Decl(declFileMethods_0.ts, 67, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 68, 54)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 68, 64)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 69, 54)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 68, 54)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 69, 64)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 68, 64)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private static privateStaticFooWithOverloads(a: string): string; ->privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 72, 49)) +>privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 70, 5), Decl(declFileMethods_0.ts, 71, 68), Decl(declFileMethods_0.ts, 72, 68)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 71, 49)) private static privateStaticFooWithOverloads(a: number): number; ->privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 73, 49)) +>privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 70, 5), Decl(declFileMethods_0.ts, 71, 68), Decl(declFileMethods_0.ts, 72, 68)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 72, 49)) private static privateStaticFooWithOverloads(a: any): any { ->privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 74, 49)) +>privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 70, 5), Decl(declFileMethods_0.ts, 71, 68), Decl(declFileMethods_0.ts, 72, 68)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 73, 49)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 74, 49)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 73, 49)) } } export interface I1 { ->I1 : Symbol(I1, Decl(declFileMethods_0.ts, 77, 1)) +>I1 : Symbol(I1, Decl(declFileMethods_0.ts, 76, 1)) /** This comment should appear for foo*/ foo(): string; ->foo : Symbol(I1.foo, Decl(declFileMethods_0.ts, 79, 21)) +>foo : Symbol(I1.foo, Decl(declFileMethods_0.ts, 78, 21)) /** This is comment for function signature*/ fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(I1.fooWithParameters, Decl(declFileMethods_0.ts, 81, 18)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 84, 22)) +>fooWithParameters : Symbol(I1.fooWithParameters, Decl(declFileMethods_0.ts, 80, 18)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 83, 22)) /** this is comment for b*/ b: number): void; ->b : Symbol(b, Decl(declFileMethods_0.ts, 84, 61)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 83, 61)) fooWithRestParameters(a: string, ...rests: string[]): string; ->fooWithRestParameters : Symbol(I1.fooWithRestParameters, Decl(declFileMethods_0.ts, 86, 25)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 88, 26)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 88, 36)) +>fooWithRestParameters : Symbol(I1.fooWithRestParameters, Decl(declFileMethods_0.ts, 85, 25)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 87, 26)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 87, 36)) fooWithOverloads(a: string): string; ->fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 88, 65), Decl(declFileMethods_0.ts, 90, 40)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 90, 21)) +>fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 87, 65), Decl(declFileMethods_0.ts, 89, 40)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 89, 21)) fooWithOverloads(a: number): number; ->fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 88, 65), Decl(declFileMethods_0.ts, 90, 40)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 91, 21)) +>fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 87, 65), Decl(declFileMethods_0.ts, 89, 40)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 90, 21)) } === tests/cases/compiler/declFileMethods_1.ts === diff --git a/tests/baselines/reference/declFileMethods.types b/tests/baselines/reference/declFileMethods.types index 44c08117e93..6c378a53593 100644 --- a/tests/baselines/reference/declFileMethods.types +++ b/tests/baselines/reference/declFileMethods.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileMethods_0.ts === - export class c1 { >c1 : c1 diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js index b2f27673c4d..37c8f6a9999 100644 --- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js +++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js @@ -1,5 +1,4 @@ //// [declFileModuleAssignmentInObjectLiteralProperty.ts] - module m1 { export class c { } diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols index b47f6faeb50..fa063aae0d5 100644 --- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols +++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/declFileModuleAssignmentInObjectLiteralProperty.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11)) +>c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 11)) } } var d = { ->d : Symbol(d, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 3)) +>d : Symbol(d, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 4, 3)) m1: { m: m1 }, ->m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 9)) ->m : Symbol(m, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 9)) +>m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 4, 9)) +>m : Symbol(m, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 9)) >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0)) m2: { c: m1.c }, ->m2 : Symbol(m2, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 18)) ->c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 7, 9)) ->m1.c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11)) +>m2 : Symbol(m2, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 18)) +>c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 9)) +>m1.c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 11)) >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 11)) }; diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types index 6fd697b7ea2..5efb1115968 100644 --- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types +++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileModuleAssignmentInObjectLiteralProperty.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js index 6b6fe3eebe4..1f1f2c78ff3 100644 --- a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js +++ b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js @@ -1,5 +1,4 @@ //// [declFileModuleWithPropertyOfTypeModule.ts] - module m { export class c { } diff --git a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols index ee69745e8d3..21a03300725 100644 --- a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols +++ b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/declFileModuleWithPropertyOfTypeModule.ts === - module m { >m : Symbol(m, Decl(declFileModuleWithPropertyOfTypeModule.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(declFileModuleWithPropertyOfTypeModule.ts, 1, 10)) +>c : Symbol(c, Decl(declFileModuleWithPropertyOfTypeModule.ts, 0, 10)) } export var a = m; ->a : Symbol(a, Decl(declFileModuleWithPropertyOfTypeModule.ts, 5, 14)) +>a : Symbol(a, Decl(declFileModuleWithPropertyOfTypeModule.ts, 4, 14)) >m : Symbol(m, Decl(declFileModuleWithPropertyOfTypeModule.ts, 0, 0)) } diff --git a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types index ecdc4396df4..2ae0e69cf01 100644 --- a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types +++ b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileModuleWithPropertyOfTypeModule.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/declFileObjectLiteralWithAccessors.js b/tests/baselines/reference/declFileObjectLiteralWithAccessors.js index 7886736f7e4..9c9f897e8b3 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithAccessors.js +++ b/tests/baselines/reference/declFileObjectLiteralWithAccessors.js @@ -1,5 +1,4 @@ //// [declFileObjectLiteralWithAccessors.ts] - function /*1*/makePoint(x: number) { return { b: 10, diff --git a/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols b/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols index 862b0b3781e..a8d68d42544 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols +++ b/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols @@ -1,36 +1,35 @@ === tests/cases/compiler/declFileObjectLiteralWithAccessors.ts === - function /*1*/makePoint(x: number) { >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithAccessors.ts, 0, 0)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 0, 24)) return { b: 10, ->b : Symbol(b, Decl(declFileObjectLiteralWithAccessors.ts, 2, 12)) +>b : Symbol(b, Decl(declFileObjectLiteralWithAccessors.ts, 1, 12)) get x() { return x; }, ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 0, 24)) set x(a: number) { this.b = a; } ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 5, 14)) ->a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 5, 14)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 4, 14)) +>a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 4, 14)) }; }; var /*4*/point = makePoint(2); ->point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) +>point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 7, 3)) >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithAccessors.ts, 0, 0)) var /*2*/x = point.x; ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 9, 3)) ->point.x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) +>point.x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 7, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) point./*3*/x = 30; ->point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) +>point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 7, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) diff --git a/tests/baselines/reference/declFileObjectLiteralWithAccessors.types b/tests/baselines/reference/declFileObjectLiteralWithAccessors.types index 389b88de565..d9357c3e052 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithAccessors.types +++ b/tests/baselines/reference/declFileObjectLiteralWithAccessors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileObjectLiteralWithAccessors.ts === - function /*1*/makePoint(x: number) { >makePoint : (x: number) => { b: number; x: number; } >x : number diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js index eb440c028d5..4d7f3fe7cfe 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js @@ -1,5 +1,4 @@ //// [declFileObjectLiteralWithOnlyGetter.ts] - function /*1*/makePoint(x: number) { return { get x() { return x; }, diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols index ef9cd96e555..abc17358cd7 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlyGetter.ts === - function /*1*/makePoint(x: number) { >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 0)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 24)) return { get x() { return x; }, ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 2, 12)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 12)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 24)) }; }; var /*4*/point = makePoint(2); ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 6, 3)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 5, 3)) >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 0)) var /*2*/x = point./*3*/x; ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 7, 3)) ->point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 2, 12)) ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 6, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 2, 12)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 6, 3)) +>point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 12)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 5, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 12)) diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types index c4e563f5a03..dd1ee568158 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlyGetter.ts === - function /*1*/makePoint(x: number) { >makePoint : (x: number) => { readonly x: number; } >x : number diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js index f7a48fe810c..188e47c8b8e 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js @@ -1,5 +1,4 @@ //// [declFileObjectLiteralWithOnlySetter.ts] - function /*1*/makePoint(x: number) { return { b: 10, diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols index f7474466140..8029baed4ad 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlySetter.ts === - function /*1*/makePoint(x: number) { >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlySetter.ts, 0, 0)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 0, 24)) return { b: 10, ->b : Symbol(b, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 12)) +>b : Symbol(b, Decl(declFileObjectLiteralWithOnlySetter.ts, 1, 12)) set x(a: number) { this.b = a; } ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) ->a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 4, 14)) ->a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 4, 14)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 14)) +>a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) +>a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) }; }; var /*3*/point = makePoint(2); ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 7, 3)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 6, 3)) >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlySetter.ts, 0, 0)) point./*2*/x = 30; ->point./*2*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 7, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) +>point./*2*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 14)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 6, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 14)) diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types index 2f15818e0f2..67beef0e910 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlySetter.ts === - function /*1*/makePoint(x: number) { >makePoint : (x: number) => { b: number; x: number; } >x : number diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.js b/tests/baselines/reference/declFilePrivateMethodOverloads.js index 531b60367a2..f2203d8d770 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.js +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.js @@ -1,5 +1,4 @@ //// [declFilePrivateMethodOverloads.ts] - interface IContext { someMethod(); } diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols index 6471ee7f5e7..5febff1b31a 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols @@ -1,76 +1,75 @@ === tests/cases/compiler/declFilePrivateMethodOverloads.ts === - interface IContext { >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) someMethod(); ->someMethod : Symbol(IContext.someMethod, Decl(declFilePrivateMethodOverloads.ts, 1, 20)) +>someMethod : Symbol(IContext.someMethod, Decl(declFilePrivateMethodOverloads.ts, 0, 20)) } class c1 { ->c1 : Symbol(c1, Decl(declFilePrivateMethodOverloads.ts, 3, 1)) +>c1 : Symbol(c1, Decl(declFilePrivateMethodOverloads.ts, 2, 1)) private _forEachBindingContext(bindingContext: IContext, fn: (bindingContext: IContext) => void); ->_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 5, 35)) +>_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 3, 10), Decl(declFilePrivateMethodOverloads.ts, 4, 101), Decl(declFilePrivateMethodOverloads.ts, 5, 113)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 35)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 5, 60)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 5, 66)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 4, 60)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 66)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private _forEachBindingContext(bindingContextArray: Array, fn: (bindingContext: IContext) => void); ->_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) ->bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 6, 35)) +>_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 3, 10), Decl(declFilePrivateMethodOverloads.ts, 4, 101), Decl(declFilePrivateMethodOverloads.ts, 5, 113)) +>bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 5, 35)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 6, 72)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 6, 78)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 5, 72)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 5, 78)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private _forEachBindingContext(context, fn: (bindingContext: IContext) => void): void { ->_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 7, 35)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 7, 43)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 7, 49)) +>_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 3, 10), Decl(declFilePrivateMethodOverloads.ts, 4, 101), Decl(declFilePrivateMethodOverloads.ts, 5, 113)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 6, 35)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 6, 43)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 6, 49)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) // Function here } private overloadWithArityDifference(bindingContext: IContext); ->overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 11, 40)) +>overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 8, 5), Decl(declFilePrivateMethodOverloads.ts, 10, 66), Decl(declFilePrivateMethodOverloads.ts, 11, 118)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 10, 40)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private overloadWithArityDifference(bindingContextArray: Array, fn: (bindingContext: IContext) => void); ->overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) ->bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 12, 40)) +>overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 8, 5), Decl(declFilePrivateMethodOverloads.ts, 10, 66), Decl(declFilePrivateMethodOverloads.ts, 11, 118)) +>bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 11, 40)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 12, 77)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 12, 83)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 11, 77)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 11, 83)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private overloadWithArityDifference(context): void { ->overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 13, 40)) +>overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 8, 5), Decl(declFilePrivateMethodOverloads.ts, 10, 66), Decl(declFilePrivateMethodOverloads.ts, 11, 118)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 12, 40)) // Function here } } declare class c2 { ->c2 : Symbol(c2, Decl(declFilePrivateMethodOverloads.ts, 16, 1)) +>c2 : Symbol(c2, Decl(declFilePrivateMethodOverloads.ts, 15, 1)) private overload1(context, fn); ->overload1 : Symbol(c2.overload1, Decl(declFilePrivateMethodOverloads.ts, 17, 18)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 18, 22)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 18, 30)) +>overload1 : Symbol(c2.overload1, Decl(declFilePrivateMethodOverloads.ts, 16, 18)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 17, 22)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 17, 30)) private overload2(context); ->overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 18, 35), Decl(declFilePrivateMethodOverloads.ts, 20, 31)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 20, 22)) +>overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 17, 35), Decl(declFilePrivateMethodOverloads.ts, 19, 31)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 19, 22)) private overload2(context, fn); ->overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 18, 35), Decl(declFilePrivateMethodOverloads.ts, 20, 31)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 21, 22)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 21, 30)) +>overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 17, 35), Decl(declFilePrivateMethodOverloads.ts, 19, 31)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 20, 22)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 20, 30)) } diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.types b/tests/baselines/reference/declFilePrivateMethodOverloads.types index 9989fea31f0..9fcd1741800 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.types +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFilePrivateMethodOverloads.ts === - interface IContext { >IContext : IContext diff --git a/tests/baselines/reference/declFilePrivateStatic.js b/tests/baselines/reference/declFilePrivateStatic.js index fb24bea7660..cb1b47735f3 100644 --- a/tests/baselines/reference/declFilePrivateStatic.js +++ b/tests/baselines/reference/declFilePrivateStatic.js @@ -1,5 +1,4 @@ //// [declFilePrivateStatic.ts] - class C { private static x = 1; static y = 1; diff --git a/tests/baselines/reference/declFilePrivateStatic.symbols b/tests/baselines/reference/declFilePrivateStatic.symbols index d3d0753123c..b8c2318bcdb 100644 --- a/tests/baselines/reference/declFilePrivateStatic.symbols +++ b/tests/baselines/reference/declFilePrivateStatic.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declFilePrivateStatic.ts === - class C { >C : Symbol(C, Decl(declFilePrivateStatic.ts, 0, 0)) private static x = 1; ->x : Symbol(C.x, Decl(declFilePrivateStatic.ts, 1, 9)) +>x : Symbol(C.x, Decl(declFilePrivateStatic.ts, 0, 9)) static y = 1; ->y : Symbol(C.y, Decl(declFilePrivateStatic.ts, 2, 25)) +>y : Symbol(C.y, Decl(declFilePrivateStatic.ts, 1, 25)) private static a() { } ->a : Symbol(C.a, Decl(declFilePrivateStatic.ts, 3, 17)) +>a : Symbol(C.a, Decl(declFilePrivateStatic.ts, 2, 17)) static b() { } ->b : Symbol(C.b, Decl(declFilePrivateStatic.ts, 5, 26)) +>b : Symbol(C.b, Decl(declFilePrivateStatic.ts, 4, 26)) private static get c() { return 1; } ->c : Symbol(C.c, Decl(declFilePrivateStatic.ts, 6, 18)) +>c : Symbol(C.c, Decl(declFilePrivateStatic.ts, 5, 18)) static get d() { return 1; } ->d : Symbol(C.d, Decl(declFilePrivateStatic.ts, 8, 40)) +>d : Symbol(C.d, Decl(declFilePrivateStatic.ts, 7, 40)) private static set e(v) { } ->e : Symbol(C.e, Decl(declFilePrivateStatic.ts, 9, 32)) ->v : Symbol(v, Decl(declFilePrivateStatic.ts, 11, 25)) +>e : Symbol(C.e, Decl(declFilePrivateStatic.ts, 8, 32)) +>v : Symbol(v, Decl(declFilePrivateStatic.ts, 10, 25)) static set f(v) { } ->f : Symbol(C.f, Decl(declFilePrivateStatic.ts, 11, 31)) ->v : Symbol(v, Decl(declFilePrivateStatic.ts, 12, 17)) +>f : Symbol(C.f, Decl(declFilePrivateStatic.ts, 10, 31)) +>v : Symbol(v, Decl(declFilePrivateStatic.ts, 11, 17)) } diff --git a/tests/baselines/reference/declFilePrivateStatic.types b/tests/baselines/reference/declFilePrivateStatic.types index 29f8f1a9aab..c7d162800a7 100644 --- a/tests/baselines/reference/declFilePrivateStatic.types +++ b/tests/baselines/reference/declFilePrivateStatic.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFilePrivateStatic.ts === - class C { >C : C diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js index 894f50fc5ab..fb0d984dbb2 100644 --- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js +++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js @@ -1,5 +1,4 @@ //// [declFileRestParametersOfFunctionAndFunctionType.ts] - function f1(...args) { } function f2(x: (...args) => void) { } function f3(x: { (...args): void }) { } diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols index 49758e4ceb1..a74786e4802 100644 --- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols +++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declFileRestParametersOfFunctionAndFunctionType.ts === - function f1(...args) { } >f1 : Symbol(f1, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 0, 0)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 0, 12)) function f2(x: (...args) => void) { } ->f2 : Symbol(f2, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 24)) ->x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 16)) +>f2 : Symbol(f2, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 0, 24)) +>x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 16)) function f3(x: { (...args): void }) { } ->f3 : Symbol(f3, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 37)) ->x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 18)) +>f3 : Symbol(f3, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 37)) +>x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 18)) function f4 void>() { } ->f4 : Symbol(f4, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 39)) ->T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 23)) +>f4 : Symbol(f4, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 39)) +>T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 23)) function f5() { } ->f5 : Symbol(f5, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 46)) ->T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 5, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 5, 25)) +>f5 : Symbol(f5, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 46)) +>T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 25)) var f6 = () => { return [10]; } ->f6 : Symbol(f6, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 6, 3)) +>f6 : Symbol(f6, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 5, 3)) diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types index 8e0cdd8d409..d94f1bfc421 100644 --- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types +++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileRestParametersOfFunctionAndFunctionType.ts === - function f1(...args) { } >f1 : (...args: any[]) => void >args : any[] diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.js b/tests/baselines/reference/declFileTypeAnnotationArrayType.js index 54dd7bbbc23..53a5ac59a47 100644 --- a/tests/baselines/reference/declFileTypeAnnotationArrayType.js +++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationArrayType.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols index 9092189c3c7..537319fe439 100644 --- a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/declFileTypeAnnotationArrayType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 8, 8)) } // Just the name function foo(): c[] { ->foo : Symbol(foo, Decl(declFileTypeAnnotationArrayType.ts, 10, 1)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationArrayType.ts, 9, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) return [new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationArrayType.ts, 15, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationArrayType.ts, 14, 1)) return [new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) @@ -36,69 +35,69 @@ function foo2() { // Qualified name function foo3(): m.c[] { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationArrayType.ts, 18, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationArrayType.ts, 17, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) return [new m.c()]; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationArrayType.ts, 23, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationArrayType.ts, 22, 1)) return m.c; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) } // Just the name with type arguments function foo5(): g[] { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationArrayType.ts, 26, 1)) ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationArrayType.ts, 25, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) return [new g()]; ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationArrayType.ts, 31, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationArrayType.ts, 30, 1)) return [new g()]; ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) } // Qualified name with type arguments function foo7(): m.g[] { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationArrayType.ts, 34, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationArrayType.ts, 33, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) return [new m.g()]; ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationArrayType.ts, 39, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationArrayType.ts, 38, 1)) return [new m.g()]; ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) } // Array of function types function foo9(): (()=>c)[] { ->foo9 : Symbol(foo9, Decl(declFileTypeAnnotationArrayType.ts, 42, 1)) +>foo9 : Symbol(foo9, Decl(declFileTypeAnnotationArrayType.ts, 41, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) return [() => new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) } function foo10() { ->foo10 : Symbol(foo10, Decl(declFileTypeAnnotationArrayType.ts, 47, 1)) +>foo10 : Symbol(foo10, Decl(declFileTypeAnnotationArrayType.ts, 46, 1)) return [() => new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.types b/tests/baselines/reference/declFileTypeAnnotationArrayType.types index 7a9d65b8a1f..6e798227826 100644 --- a/tests/baselines/reference/declFileTypeAnnotationArrayType.types +++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationArrayType.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js index fc877ab4b32..10d6539be94 100644 --- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js +++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationBuiltInType.ts] - // string function foo(): string { return ""; diff --git a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols index 62de15530b7..91b022e1418 100644 --- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationBuiltInType.ts === - // string function foo(): string { >foo : Symbol(foo, Decl(declFileTypeAnnotationBuiltInType.ts, 0, 0)) @@ -7,56 +6,56 @@ function foo(): string { return ""; } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationBuiltInType.ts, 4, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationBuiltInType.ts, 3, 1)) return ""; } // number function foo3(): number { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationBuiltInType.ts, 7, 1)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationBuiltInType.ts, 6, 1)) return 10; } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationBuiltInType.ts, 12, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationBuiltInType.ts, 11, 1)) return 10; } // boolean function foo5(): boolean { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationBuiltInType.ts, 15, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationBuiltInType.ts, 14, 1)) return true; } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationBuiltInType.ts, 20, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationBuiltInType.ts, 19, 1)) return false; } // void function foo7(): void { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationBuiltInType.ts, 23, 1)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationBuiltInType.ts, 22, 1)) return; } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationBuiltInType.ts, 28, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationBuiltInType.ts, 27, 1)) return; } // any function foo9(): any { ->foo9 : Symbol(foo9, Decl(declFileTypeAnnotationBuiltInType.ts, 31, 1)) +>foo9 : Symbol(foo9, Decl(declFileTypeAnnotationBuiltInType.ts, 30, 1)) return undefined; >undefined : Symbol(undefined) } function foo10() { ->foo10 : Symbol(foo10, Decl(declFileTypeAnnotationBuiltInType.ts, 36, 1)) +>foo10 : Symbol(foo10, Decl(declFileTypeAnnotationBuiltInType.ts, 35, 1)) return undefined; >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types index 87776b3b417..c30b5b95b81 100644 --- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types +++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationBuiltInType.ts === - // string function foo(): string { >foo : () => string diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.js b/tests/baselines/reference/declFileTypeAnnotationParenType.js index 4707007cd1b..e867f2069c4 100644 --- a/tests/baselines/reference/declFileTypeAnnotationParenType.js +++ b/tests/baselines/reference/declFileTypeAnnotationParenType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationParenType.ts] - class c { private p: string; } diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols index 7186da48fd7..fbe94d26da4 100644 --- a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/declFileTypeAnnotationParenType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) private p: string; ->p : Symbol(c.p, Decl(declFileTypeAnnotationParenType.ts, 1, 9)) +>p : Symbol(c.p, Decl(declFileTypeAnnotationParenType.ts, 0, 9)) } var x: (() => c)[] = [() => new c()]; ->x : Symbol(x, Decl(declFileTypeAnnotationParenType.ts, 5, 3)) +>x : Symbol(x, Decl(declFileTypeAnnotationParenType.ts, 4, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) var y = [() => new c()]; ->y : Symbol(y, Decl(declFileTypeAnnotationParenType.ts, 6, 3)) +>y : Symbol(y, Decl(declFileTypeAnnotationParenType.ts, 5, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) var k: (() => c) | string = (() => new c()) || ""; ->k : Symbol(k, Decl(declFileTypeAnnotationParenType.ts, 8, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationParenType.ts, 7, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) var l = (() => new c()) || ""; ->l : Symbol(l, Decl(declFileTypeAnnotationParenType.ts, 9, 3)) +>l : Symbol(l, Decl(declFileTypeAnnotationParenType.ts, 8, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.types b/tests/baselines/reference/declFileTypeAnnotationParenType.types index 1fd0b6ee5d9..a73c9bba0a9 100644 --- a/tests/baselines/reference/declFileTypeAnnotationParenType.types +++ b/tests/baselines/reference/declFileTypeAnnotationParenType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationParenType.ts === - class c { >c : c diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js index faa76cc869c..9332c175fd0 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationStringLiteral.ts] - function foo(a: "hello"): number; function foo(a: "name"): string; function foo(a: string): string | number; diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols index f48ced073d5..d2e6afe63e8 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/declFileTypeAnnotationStringLiteral.ts === - function foo(a: "hello"): number; ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 1, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 13)) function foo(a: "name"): string; ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 2, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 1, 13)) function foo(a: string): string | number; ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 2, 13)) function foo(a: string): string | number { ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) if (a === "hello") { ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) return a.length; >a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } return a; ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) } diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types index b1a85f3fc30..04bd4e53e8e 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationStringLiteral.ts === - function foo(a: "hello"): number; >foo : { (a: "hello"): number; (a: "name"): string; (a: string): string | number; } >a : "hello" diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.js b/tests/baselines/reference/declFileTypeAnnotationTupleType.js index 323fdce03f9..f4f1a32c8c0 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTupleType.js +++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTupleType.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols index 9eea6dfd9f9..6f2314d22b5 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/declFileTypeAnnotationTupleType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 8, 8)) } // Just the name var k: [c, m.c] = [new c(), new m.c()]; ->k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 13, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 12, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) var l = k; ->l : Symbol(l, Decl(declFileTypeAnnotationTupleType.ts, 14, 3)) ->k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 13, 3)) +>l : Symbol(l, Decl(declFileTypeAnnotationTupleType.ts, 13, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 12, 3)) var x: [g, m.g, () => c] = [new g(), new m.g(), () => new c()]; ->x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 16, 3)) ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 8, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) +>x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 15, 3)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 7, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 8, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 7, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) var y = x; ->y : Symbol(y, Decl(declFileTypeAnnotationTupleType.ts, 17, 3)) ->x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 16, 3)) +>y : Symbol(y, Decl(declFileTypeAnnotationTupleType.ts, 16, 3)) +>x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 15, 3)) diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.types b/tests/baselines/reference/declFileTypeAnnotationTupleType.types index aad0760fade..03de87243de 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTupleType.types +++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTupleType.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js index 171625efe1a..1ca73a78891 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeAlias.ts] - module M { export type Value = string | number | boolean; export var x: Value; diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols index d12902b6f19..168971f364f 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols @@ -1,63 +1,62 @@ === tests/cases/compiler/declFileTypeAnnotationTypeAlias.ts === - module M { ->M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 22, 1)) +>M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 21, 1)) export type Value = string | number | boolean; ->Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 1, 10)) +>Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 10)) export var x: Value; ->x : Symbol(x, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 14)) ->Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 1, 10)) +>x : Symbol(x, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 14)) +>Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 10)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 24)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 24)) } export type C = c; ->C : Symbol(C, Decl(declFileTypeAnnotationTypeAlias.ts, 6, 5)) ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 24)) +>C : Symbol(C, Decl(declFileTypeAnnotationTypeAlias.ts, 5, 5)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 24)) export module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 8, 22)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 7, 22)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 10, 21)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 9, 21)) } } export type MC = m.c; ->MC : Symbol(MC, Decl(declFileTypeAnnotationTypeAlias.ts, 13, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 8, 22)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeAlias.ts, 10, 21)) +>MC : Symbol(MC, Decl(declFileTypeAnnotationTypeAlias.ts, 12, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 7, 22)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeAlias.ts, 9, 21)) export type fc = () => c; ->fc : Symbol(fc, Decl(declFileTypeAnnotationTypeAlias.ts, 15, 25)) ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 24)) +>fc : Symbol(fc, Decl(declFileTypeAnnotationTypeAlias.ts, 14, 25)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 24)) } interface Window { ->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 18, 1)) +>Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1)) someMethod(); ->someMethod : Symbol(Window.someMethod, Decl(declFileTypeAnnotationTypeAlias.ts, 20, 18)) +>someMethod : Symbol(Window.someMethod, Decl(declFileTypeAnnotationTypeAlias.ts, 19, 18)) } module M { ->M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 22, 1)) +>M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 21, 1)) export type W = Window | string; ->W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 10)) ->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 18, 1)) +>W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 23, 10)) +>Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1)) export module N { ->N : Symbol(N, Decl(declFileTypeAnnotationTypeAlias.ts, 25, 36)) +>N : Symbol(N, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 36)) export class Window { } ->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 26, 21)) +>Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 25, 21)) export var p: W; ->p : Symbol(p, Decl(declFileTypeAnnotationTypeAlias.ts, 28, 18)) ->W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 10)) +>p : Symbol(p, Decl(declFileTypeAnnotationTypeAlias.ts, 27, 18)) +>W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 23, 10)) } } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types index 53db7a54d0d..37955f25a6d 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeAlias.ts === - module M { >M : typeof M diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js index befd96a9fa7..f2247e8daa9 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeLiteral.ts] - class c { } class g { diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols index 6a3f2100fab..cea4cd09db3 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/declFileTypeAnnotationTypeLiteral.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 8)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 5, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 10)) } } // Object literal with everything var x: { ->x : Symbol(x, Decl(declFileTypeAnnotationTypeLiteral.ts, 11, 3)) +>x : Symbol(x, Decl(declFileTypeAnnotationTypeLiteral.ts, 10, 3)) // Call signatures (a: number): c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 13, 5)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 12, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) (a: string): g; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 14, 5)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 13, 5)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) // Construct signatures new (a: number): c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 17, 9)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 16, 9)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) new (a: string): m.c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 18, 9)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 5, 10)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 17, 9)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 10)) // Indexers [n: number]: c; ->n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 21, 5)) +>n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 20, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) [n: string]: c; ->n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 22, 5)) +>n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 21, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) // Properties a: c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 22, 19)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 21, 19)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) b: g; ->b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 25, 9)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) +>b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 24, 9)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) // methods m1(): g; ->m1 : Symbol(m1, Decl(declFileTypeAnnotationTypeLiteral.ts, 26, 17)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) +>m1 : Symbol(m1, Decl(declFileTypeAnnotationTypeLiteral.ts, 25, 17)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) m2(a: string, b?: number, ...c: c[]): string; ->m2 : Symbol(m2, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 20)) ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 30, 7)) ->b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 30, 17)) ->c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 30, 29)) +>m2 : Symbol(m2, Decl(declFileTypeAnnotationTypeLiteral.ts, 28, 20)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 7)) +>b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 17)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 29)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) }; @@ -73,13 +72,13 @@ var x: { // Function type var y: (a: string) => string; ->y : Symbol(y, Decl(declFileTypeAnnotationTypeLiteral.ts, 35, 3)) ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 35, 8)) +>y : Symbol(y, Decl(declFileTypeAnnotationTypeLiteral.ts, 34, 3)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 34, 8)) // constructor type var z: new (a: string) => m.c; ->z : Symbol(z, Decl(declFileTypeAnnotationTypeLiteral.ts, 38, 3)) ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 38, 12)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 5, 10)) +>z : Symbol(z, Decl(declFileTypeAnnotationTypeLiteral.ts, 37, 3)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 37, 12)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 10)) diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types index e2092008358..e1aa1a26611 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeLiteral.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js index e64e81e4939..e2d6fee1f4f 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeQuery.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols index f5970ce15f5..874a0546dbd 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/declFileTypeAnnotationTypeQuery.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 8)) } // Just the name function foo(): typeof c { ->foo : Symbol(foo, Decl(declFileTypeAnnotationTypeQuery.ts, 10, 1)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationTypeQuery.ts, 9, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) return c; >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeQuery.ts, 15, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeQuery.ts, 14, 1)) return c; >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) @@ -36,57 +35,57 @@ function foo2() { // Qualified name function foo3(): typeof m.c { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeQuery.ts, 18, 1)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeQuery.ts, 17, 1)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) return m.c; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeQuery.ts, 23, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeQuery.ts, 22, 1)) return m.c; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) } // Just the name with type arguments function foo5(): typeof g { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeQuery.ts, 26, 1)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeQuery.ts, 25, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) return g; ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeQuery.ts, 31, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeQuery.ts, 30, 1)) return g; ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) } // Qualified name with type arguments function foo7(): typeof m.g { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeQuery.ts, 34, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeQuery.ts, 33, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) return m.g ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeQuery.ts, 39, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeQuery.ts, 38, 1)) return m.g ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types index 01fce150ab8..cdf9ab37936 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeQuery.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeReference.js b/tests/baselines/reference/declFileTypeAnnotationTypeReference.js index 7d2e7102fb6..7eebd30e54b 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeReference.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeReference.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeReference.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols index c6e27ecdceb..ab8ab66b004 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/declFileTypeAnnotationTypeReference.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 8, 8)) } // Just the name function foo(): c { ->foo : Symbol(foo, Decl(declFileTypeAnnotationTypeReference.ts, 10, 1)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationTypeReference.ts, 9, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) return new c(); >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeReference.ts, 15, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeReference.ts, 14, 1)) return new c(); >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) @@ -36,55 +35,55 @@ function foo2() { // Qualified name function foo3(): m.c { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeReference.ts, 18, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeReference.ts, 17, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) return new m.c(); ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeReference.ts, 23, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeReference.ts, 22, 1)) return new m.c(); ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) } // Just the name with type arguments function foo5(): g { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeReference.ts, 26, 1)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeReference.ts, 25, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) return new g(); ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeReference.ts, 31, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeReference.ts, 30, 1)) return new g(); ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) } // Qualified name with type arguments function foo7(): m.g { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeReference.ts, 34, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeReference.ts, 33, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) return new m.g(); ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeReference.ts, 39, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeReference.ts, 38, 1)) return new m.g(); ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeReference.types b/tests/baselines/reference/declFileTypeAnnotationTypeReference.types index 1d85ad19293..1320354a3a7 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeReference.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeReference.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeReference.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.js b/tests/baselines/reference/declFileTypeAnnotationUnionType.js index c90501bab5c..b821d15269c 100644 --- a/tests/baselines/reference/declFileTypeAnnotationUnionType.js +++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationUnionType.ts] - class c { private p: string; } diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols index ac4884326eb..4424ae7762d 100644 --- a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/declFileTypeAnnotationUnionType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) private p: string; ->p : Symbol(c.p, Decl(declFileTypeAnnotationUnionType.ts, 1, 9)) +>p : Symbol(c.p, Decl(declFileTypeAnnotationUnionType.ts, 0, 9)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) private q: string; ->q : Symbol(c.q, Decl(declFileTypeAnnotationUnionType.ts, 5, 20)) +>q : Symbol(c.q, Decl(declFileTypeAnnotationUnionType.ts, 4, 20)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 8, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 7, 19)) private r: string; ->r : Symbol(g.r, Decl(declFileTypeAnnotationUnionType.ts, 8, 23)) +>r : Symbol(g.r, Decl(declFileTypeAnnotationUnionType.ts, 7, 23)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 12, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 11, 8)) private s: string; ->s : Symbol(g.s, Decl(declFileTypeAnnotationUnionType.ts, 12, 12)) +>s : Symbol(g.s, Decl(declFileTypeAnnotationUnionType.ts, 11, 12)) } // Just the name var k: c | m.c = new c() || new m.c(); ->k : Symbol(k, Decl(declFileTypeAnnotationUnionType.ts, 17, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationUnionType.ts, 16, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) var l = new c() || new m.c(); ->l : Symbol(l, Decl(declFileTypeAnnotationUnionType.ts, 18, 3)) +>l : Symbol(l, Decl(declFileTypeAnnotationUnionType.ts, 17, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) var x: g | m.g | (() => c) = new g() || new m.g() || (() => new c()); ->x : Symbol(x, Decl(declFileTypeAnnotationUnionType.ts, 20, 3)) ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) +>x : Symbol(x, Decl(declFileTypeAnnotationUnionType.ts, 19, 3)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) var y = new g() || new m.g() || (() => new c()); ->y : Symbol(y, Decl(declFileTypeAnnotationUnionType.ts, 21, 3)) ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) +>y : Symbol(y, Decl(declFileTypeAnnotationUnionType.ts, 20, 3)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.types b/tests/baselines/reference/declFileTypeAnnotationUnionType.types index a412f60b36e..115aa7339ca 100644 --- a/tests/baselines/reference/declFileTypeAnnotationUnionType.types +++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationUnionType.ts === - class c { >c : c diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt index b6130864d8b..771960ba788 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(16,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(21,13): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4037: Parameter 'foo3' of public property setter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(33,25): error TS4037: Parameter 'foo4' of public property setter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(37,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(72,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(77,13): error TS4042: Return type of public property getter from exported class has or is using name 'm2.public2' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4037: Parameter 'foo113' of public property setter from exported class has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(89,27): error TS4037: Parameter 'foo114' of public property setter from exported class has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(15,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(20,13): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(25,25): error TS4037: Parameter 'foo3' of public property setter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(32,25): error TS4037: Parameter 'foo4' of public property setter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(36,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(71,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(76,13): error TS4042: Return type of public property getter from exported class has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(81,27): error TS4037: Parameter 'foo113' of public property setter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(88,27): error TS4037: Parameter 'foo114' of public property setter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(92,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts (10 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js index 957dbb98263..be777c3e8ba 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorAccessors.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt index 7dbe3617de9..339ae67eea4 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(15,34): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(17,26): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(40,35): error TS4078: Parameter 'param' of exported function has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(42,28): error TS4077: Parameter 'param' of exported function has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(14,34): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(16,26): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(39,35): error TS4078: Parameter 'param' of exported function has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(41,28): error TS4077: Parameter 'param' of exported function has or is using name 'm2.public2' from private module 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts (4 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js index 7774ee27206..25b59845c14 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt index 449af75bf61..492e6615efa 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(17,29): error TS4060: Return type of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(20,21): error TS4060: Return type of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(50,31): error TS4060: Return type of exported function has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(53,21): error TS4059: Return type of exported function has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(16,29): error TS4060: Return type of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(19,21): error TS4060: Return type of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(49,31): error TS4060: Return type of exported function has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(52,21): error TS4059: Return type of exported function has or is using name 'm2.public2' from private module 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts (4 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js index 7e26816beb8..6cc74c0188a 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt index a9fd72ae569..919fd5cd657 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(10,23): error TS4025: Exported variable 'p' has or is using private name 'W'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(33,22): error TS4081: Exported type alias 't2' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(36,23): error TS4081: Exported type alias 't12' has or is using private name 'public1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(39,24): error TS4081: Exported type alias 't112' has or is using private name 'm3'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(9,23): error TS4025: Exported variable 'p' has or is using private name 'W'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(32,22): error TS4081: Exported type alias 't2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(35,23): error TS4081: Exported type alias 't12' has or is using private name 'public1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(38,24): error TS4081: Exported type alias 't112' has or is using private name 'm3'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts (4 errors) ==== - interface Window { someMethod(); } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js index 2b7052903fb..811ee0575fe 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorTypeAlias.ts] - interface Window { someMethod(); } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt index 8cba0d12464..a8d8023e830 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt @@ -1,25 +1,24 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(11,12): error TS4025: Exported variable 'x' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(12,12): error TS4025: Exported variable 'x' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,13): error TS4025: Exported variable 'x' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,19): error TS4025: Exported variable 'x' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4025: Exported variable 'x' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(16,22): error TS4025: Exported variable 'x' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4024: Exported variable 'x2' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Exported variable 'x2' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4024: Exported variable 'x3' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Exported variable 'x3' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4025: Exported variable 'y' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,36): error TS4025: Exported variable 'y' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4024: Exported variable 'y2' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Exported variable 'y2' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4025: Exported variable 'z' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,40): error TS4025: Exported variable 'z' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4024: Exported variable 'z2' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Exported variable 'z2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(10,12): error TS4025: Exported variable 'x' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(11,12): error TS4025: Exported variable 'x' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(12,13): error TS4025: Exported variable 'x' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,19): error TS4025: Exported variable 'x' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,22): error TS4025: Exported variable 'x' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4025: Exported variable 'x' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(17,16): error TS4024: Exported variable 'x2' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(17,16): error TS4025: Exported variable 'x2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(24,16): error TS4024: Exported variable 'x3' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(24,16): error TS4025: Exported variable 'x3' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(27,23): error TS4025: Exported variable 'y' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(27,36): error TS4025: Exported variable 'y' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,16): error TS4024: Exported variable 'y2' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,16): error TS4025: Exported variable 'y2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(31,27): error TS4025: Exported variable 'z' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(31,40): error TS4025: Exported variable 'z' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,16): error TS4024: Exported variable 'z2' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,16): error TS4025: Exported variable 'z2' has or is using private name 'private1'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts (18 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js index 46dfaf3c77e..41f1a094eae 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorTypeLiteral.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt index 33771b85dd4..6a9e5961831 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(13,19): error TS4025: Exported variable 'k' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(14,16): error TS4025: Exported variable 'l' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(30,20): error TS4025: Exported variable 'k3' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(31,16): error TS4024: Exported variable 'l3' has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(12,19): error TS4025: Exported variable 'k' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(13,16): error TS4025: Exported variable 'l' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(29,20): error TS4025: Exported variable 'k3' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(30,16): error TS4024: Exported variable 'l3' has or is using name 'm2.public2' from private module 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts (4 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js index a75903c7369..414a949ce93 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeofClass.js b/tests/baselines/reference/declFileTypeofClass.js index 7058ace0c94..03ed0febe73 100644 --- a/tests/baselines/reference/declFileTypeofClass.js +++ b/tests/baselines/reference/declFileTypeofClass.js @@ -1,5 +1,4 @@ //// [declFileTypeofClass.ts] - class c { static x : string; private static y: number; diff --git a/tests/baselines/reference/declFileTypeofClass.symbols b/tests/baselines/reference/declFileTypeofClass.symbols index 0594edeef77..443b07f1081 100644 --- a/tests/baselines/reference/declFileTypeofClass.symbols +++ b/tests/baselines/reference/declFileTypeofClass.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/declFileTypeofClass.ts === - class c { >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) static x : string; ->x : Symbol(c.x, Decl(declFileTypeofClass.ts, 1, 9)) +>x : Symbol(c.x, Decl(declFileTypeofClass.ts, 0, 9)) private static y: number; ->y : Symbol(c.y, Decl(declFileTypeofClass.ts, 2, 22)) +>y : Symbol(c.y, Decl(declFileTypeofClass.ts, 1, 22)) private x3: string; ->x3 : Symbol(c.x3, Decl(declFileTypeofClass.ts, 3, 29)) +>x3 : Symbol(c.x3, Decl(declFileTypeofClass.ts, 2, 29)) public y3: number; ->y3 : Symbol(c.y3, Decl(declFileTypeofClass.ts, 4, 23)) +>y3 : Symbol(c.y3, Decl(declFileTypeofClass.ts, 3, 23)) } var x: c; ->x : Symbol(x, Decl(declFileTypeofClass.ts, 8, 3)) +>x : Symbol(x, Decl(declFileTypeofClass.ts, 7, 3)) >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) var y = c; ->y : Symbol(y, Decl(declFileTypeofClass.ts, 9, 3)) +>y : Symbol(y, Decl(declFileTypeofClass.ts, 8, 3)) >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) var z: typeof c; ->z : Symbol(z, Decl(declFileTypeofClass.ts, 10, 3)) +>z : Symbol(z, Decl(declFileTypeofClass.ts, 9, 3)) >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) class genericC ->genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 10, 16)) ->T : Symbol(T, Decl(declFileTypeofClass.ts, 11, 15)) +>genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 9, 16)) +>T : Symbol(T, Decl(declFileTypeofClass.ts, 10, 15)) { } var genericX = genericC; ->genericX : Symbol(genericX, Decl(declFileTypeofClass.ts, 14, 3)) ->genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 10, 16)) +>genericX : Symbol(genericX, Decl(declFileTypeofClass.ts, 13, 3)) +>genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 9, 16)) diff --git a/tests/baselines/reference/declFileTypeofClass.types b/tests/baselines/reference/declFileTypeofClass.types index 119ad9bb7d4..f2f71639f7f 100644 --- a/tests/baselines/reference/declFileTypeofClass.types +++ b/tests/baselines/reference/declFileTypeofClass.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofClass.ts === - class c { >c : c diff --git a/tests/baselines/reference/declFileTypeofEnum.js b/tests/baselines/reference/declFileTypeofEnum.js index 5b1c6977472..0e31a7c3511 100644 --- a/tests/baselines/reference/declFileTypeofEnum.js +++ b/tests/baselines/reference/declFileTypeofEnum.js @@ -1,5 +1,4 @@ //// [declFileTypeofEnum.ts] - enum days { monday, tuesday, diff --git a/tests/baselines/reference/declFileTypeofEnum.symbols b/tests/baselines/reference/declFileTypeofEnum.symbols index 9980167788a..bd154224243 100644 --- a/tests/baselines/reference/declFileTypeofEnum.symbols +++ b/tests/baselines/reference/declFileTypeofEnum.symbols @@ -1,41 +1,40 @@ === tests/cases/compiler/declFileTypeofEnum.ts === - enum days { >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) monday, ->monday : Symbol(days.monday, Decl(declFileTypeofEnum.ts, 1, 11)) +>monday : Symbol(days.monday, Decl(declFileTypeofEnum.ts, 0, 11)) tuesday, ->tuesday : Symbol(days.tuesday, Decl(declFileTypeofEnum.ts, 2, 11)) +>tuesday : Symbol(days.tuesday, Decl(declFileTypeofEnum.ts, 1, 11)) wednesday, ->wednesday : Symbol(days.wednesday, Decl(declFileTypeofEnum.ts, 3, 12)) +>wednesday : Symbol(days.wednesday, Decl(declFileTypeofEnum.ts, 2, 12)) thursday, ->thursday : Symbol(days.thursday, Decl(declFileTypeofEnum.ts, 4, 14)) +>thursday : Symbol(days.thursday, Decl(declFileTypeofEnum.ts, 3, 14)) friday, ->friday : Symbol(days.friday, Decl(declFileTypeofEnum.ts, 5, 13)) +>friday : Symbol(days.friday, Decl(declFileTypeofEnum.ts, 4, 13)) saturday, ->saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 6, 11)) +>saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 5, 11)) sunday ->sunday : Symbol(days.sunday, Decl(declFileTypeofEnum.ts, 7, 13)) +>sunday : Symbol(days.sunday, Decl(declFileTypeofEnum.ts, 6, 13)) } var weekendDay = days.saturday; ->weekendDay : Symbol(weekendDay, Decl(declFileTypeofEnum.ts, 11, 3)) ->days.saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 6, 11)) +>weekendDay : Symbol(weekendDay, Decl(declFileTypeofEnum.ts, 10, 3)) +>days.saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 5, 11)) >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) ->saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 6, 11)) +>saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 5, 11)) var daysOfMonth = days; ->daysOfMonth : Symbol(daysOfMonth, Decl(declFileTypeofEnum.ts, 12, 3)) +>daysOfMonth : Symbol(daysOfMonth, Decl(declFileTypeofEnum.ts, 11, 3)) >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) var daysOfYear: typeof days; ->daysOfYear : Symbol(daysOfYear, Decl(declFileTypeofEnum.ts, 13, 3)) +>daysOfYear : Symbol(daysOfYear, Decl(declFileTypeofEnum.ts, 12, 3)) >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeofEnum.types b/tests/baselines/reference/declFileTypeofEnum.types index 1d69d0594c8..b822cfa68d8 100644 --- a/tests/baselines/reference/declFileTypeofEnum.types +++ b/tests/baselines/reference/declFileTypeofEnum.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofEnum.ts === - enum days { >days : days diff --git a/tests/baselines/reference/declFileTypeofFunction.js b/tests/baselines/reference/declFileTypeofFunction.js index 656e02b8ddd..ae1f1b0fcf2 100644 --- a/tests/baselines/reference/declFileTypeofFunction.js +++ b/tests/baselines/reference/declFileTypeofFunction.js @@ -1,5 +1,4 @@ //// [declFileTypeofFunction.ts] - function f(n: typeof f): string; function f(n: typeof g): string; function f() { return undefined; } diff --git a/tests/baselines/reference/declFileTypeofFunction.symbols b/tests/baselines/reference/declFileTypeofFunction.symbols index 649c09cba06..cdab4ca0aa3 100644 --- a/tests/baselines/reference/declFileTypeofFunction.symbols +++ b/tests/baselines/reference/declFileTypeofFunction.symbols @@ -1,82 +1,81 @@ === tests/cases/compiler/declFileTypeofFunction.ts === - function f(n: typeof f): string; ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 1, 11)) ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 0, 11)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) function f(n: typeof g): string; ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 2, 11)) ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 1, 11)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) function f() { return undefined; } ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) >undefined : Symbol(undefined) function g(n: typeof g): number; ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 4, 11)) ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 3, 11)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) function g(n: typeof f): number; ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 5, 11)) ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 4, 11)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) function g() { return undefined; } ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) >undefined : Symbol(undefined) var b: () => typeof b; ->b : Symbol(b, Decl(declFileTypeofFunction.ts, 8, 3)) ->b : Symbol(b, Decl(declFileTypeofFunction.ts, 8, 3)) +>b : Symbol(b, Decl(declFileTypeofFunction.ts, 7, 3)) +>b : Symbol(b, Decl(declFileTypeofFunction.ts, 7, 3)) function b1() { ->b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 8, 22)) +>b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 7, 22)) return b1; ->b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 8, 22)) +>b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 7, 22)) } function foo(): typeof foo { ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) return null; } var foo1: typeof foo; ->foo1 : Symbol(foo1, Decl(declFileTypeofFunction.ts, 17, 3)) ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) +>foo1 : Symbol(foo1, Decl(declFileTypeofFunction.ts, 16, 3)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) var foo2 = foo; ->foo2 : Symbol(foo2, Decl(declFileTypeofFunction.ts, 18, 3)) ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeofFunction.ts, 17, 3)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) var foo3 = function () { ->foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3)) +>foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 19, 3)) return foo3; ->foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3)) +>foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 19, 3)) } var x = () => { ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 22, 3)) return x; ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 22, 3)) } function foo5(x: number) { ->foo5 : Symbol(foo5, Decl(declFileTypeofFunction.ts, 25, 1)) ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 27, 14)) +>foo5 : Symbol(foo5, Decl(declFileTypeofFunction.ts, 24, 1)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 26, 14)) function bar(x: number) { ->bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 27, 26)) ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 28, 17)) +>bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 26, 26)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 27, 17)) return x; ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 28, 17)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 27, 17)) } return bar; ->bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 27, 26)) +>bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 26, 26)) } diff --git a/tests/baselines/reference/declFileTypeofFunction.types b/tests/baselines/reference/declFileTypeofFunction.types index b47b07035d1..fdc06020663 100644 --- a/tests/baselines/reference/declFileTypeofFunction.types +++ b/tests/baselines/reference/declFileTypeofFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofFunction.ts === - function f(n: typeof f): string; >f : { (n: typeof f): string; (n: { (n: typeof g): number; (n: typeof f): number; }): string; } >n : { (n: typeof f): string; (n: { (n: typeof g): number; (n: typeof f): number; }): string; } diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.js b/tests/baselines/reference/declFileTypeofInAnonymousType.js index 656cd49ebfa..059812e9f49 100644 --- a/tests/baselines/reference/declFileTypeofInAnonymousType.js +++ b/tests/baselines/reference/declFileTypeofInAnonymousType.js @@ -1,5 +1,4 @@ //// [declFileTypeofInAnonymousType.ts] - module m1 { export class c { } diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols index 426f953d6f2..42f63de6341 100644 --- a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols +++ b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols @@ -1,77 +1,76 @@ === tests/cases/compiler/declFileTypeofInAnonymousType.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) } export enum e { ->e : Symbol(e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>e : Symbol(e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) weekday, ->weekday : Symbol(e.weekday, Decl(declFileTypeofInAnonymousType.ts, 4, 19)) +>weekday : Symbol(e.weekday, Decl(declFileTypeofInAnonymousType.ts, 3, 19)) weekend, ->weekend : Symbol(e.weekend, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) +>weekend : Symbol(e.weekend, Decl(declFileTypeofInAnonymousType.ts, 4, 16)) holiday ->holiday : Symbol(e.holiday, Decl(declFileTypeofInAnonymousType.ts, 6, 16)) +>holiday : Symbol(e.holiday, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) } } var a: { c: m1.c; }; ->a : Symbol(a, Decl(declFileTypeofInAnonymousType.ts, 10, 3)) ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 10, 8)) +>a : Symbol(a, Decl(declFileTypeofInAnonymousType.ts, 9, 3)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 9, 8)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) var b = { ->b : Symbol(b, Decl(declFileTypeofInAnonymousType.ts, 11, 3)) +>b : Symbol(b, Decl(declFileTypeofInAnonymousType.ts, 10, 3)) c: m1.c, ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 11, 9)) ->m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 10, 9)) +>m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) m1: m1 ->m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 12, 12)) +>m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 11, 12)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) }; var c = { m1: m1 }; ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 15, 3)) ->m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 15, 9)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 14, 3)) +>m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 14, 9)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) var d = { ->d : Symbol(d, Decl(declFileTypeofInAnonymousType.ts, 16, 3)) +>d : Symbol(d, Decl(declFileTypeofInAnonymousType.ts, 15, 3)) m: { mod: m1 }, ->m : Symbol(m, Decl(declFileTypeofInAnonymousType.ts, 16, 9)) ->mod : Symbol(mod, Decl(declFileTypeofInAnonymousType.ts, 17, 8)) +>m : Symbol(m, Decl(declFileTypeofInAnonymousType.ts, 15, 9)) +>mod : Symbol(mod, Decl(declFileTypeofInAnonymousType.ts, 16, 8)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) mc: { cl: m1.c }, ->mc : Symbol(mc, Decl(declFileTypeofInAnonymousType.ts, 17, 19)) ->cl : Symbol(cl, Decl(declFileTypeofInAnonymousType.ts, 18, 9)) ->m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>mc : Symbol(mc, Decl(declFileTypeofInAnonymousType.ts, 16, 19)) +>cl : Symbol(cl, Decl(declFileTypeofInAnonymousType.ts, 17, 9)) +>m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) me: { en: m1.e }, ->me : Symbol(me, Decl(declFileTypeofInAnonymousType.ts, 18, 21)) ->en : Symbol(en, Decl(declFileTypeofInAnonymousType.ts, 19, 9)) ->m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>me : Symbol(me, Decl(declFileTypeofInAnonymousType.ts, 17, 21)) +>en : Symbol(en, Decl(declFileTypeofInAnonymousType.ts, 18, 9)) +>m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) mh: m1.e.holiday ->mh : Symbol(mh, Decl(declFileTypeofInAnonymousType.ts, 19, 21)) ->m1.e.holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 6, 16)) ->m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>mh : Symbol(mh, Decl(declFileTypeofInAnonymousType.ts, 18, 21)) +>m1.e.holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) +>m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) ->holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 6, 16)) +>e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) +>holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) }; diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.types b/tests/baselines/reference/declFileTypeofInAnonymousType.types index 2ab5e673fb2..2a3098b0859 100644 --- a/tests/baselines/reference/declFileTypeofInAnonymousType.types +++ b/tests/baselines/reference/declFileTypeofInAnonymousType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofInAnonymousType.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileTypeofModule.js b/tests/baselines/reference/declFileTypeofModule.js index fad0c1b25bb..c5e268cb4fc 100644 --- a/tests/baselines/reference/declFileTypeofModule.js +++ b/tests/baselines/reference/declFileTypeofModule.js @@ -1,5 +1,4 @@ //// [declFileTypeofModule.ts] - module m1 { export var c: string; } diff --git a/tests/baselines/reference/declFileTypeofModule.symbols b/tests/baselines/reference/declFileTypeofModule.symbols index c84185b105d..feb99a68356 100644 --- a/tests/baselines/reference/declFileTypeofModule.symbols +++ b/tests/baselines/reference/declFileTypeofModule.symbols @@ -1,32 +1,31 @@ === tests/cases/compiler/declFileTypeofModule.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileTypeofModule.ts, 0, 0)) export var c: string; ->c : Symbol(c, Decl(declFileTypeofModule.ts, 2, 14)) +>c : Symbol(c, Decl(declFileTypeofModule.ts, 1, 14)) } var m1_1 = m1; ->m1_1 : Symbol(m1_1, Decl(declFileTypeofModule.ts, 4, 3)) +>m1_1 : Symbol(m1_1, Decl(declFileTypeofModule.ts, 3, 3)) >m1 : Symbol(m1, Decl(declFileTypeofModule.ts, 0, 0)) var m1_2: typeof m1; ->m1_2 : Symbol(m1_2, Decl(declFileTypeofModule.ts, 5, 3)) +>m1_2 : Symbol(m1_2, Decl(declFileTypeofModule.ts, 4, 3)) >m1 : Symbol(m1, Decl(declFileTypeofModule.ts, 0, 0)) module m2 { ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) export var d: typeof m2; ->d : Symbol(d, Decl(declFileTypeofModule.ts, 8, 14)) ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>d : Symbol(d, Decl(declFileTypeofModule.ts, 7, 14)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) } var m2_1 = m2; ->m2_1 : Symbol(m2_1, Decl(declFileTypeofModule.ts, 11, 3)) ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>m2_1 : Symbol(m2_1, Decl(declFileTypeofModule.ts, 10, 3)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) var m2_2: typeof m2; ->m2_2 : Symbol(m2_2, Decl(declFileTypeofModule.ts, 12, 3)) ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>m2_2 : Symbol(m2_2, Decl(declFileTypeofModule.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) diff --git a/tests/baselines/reference/declFileTypeofModule.types b/tests/baselines/reference/declFileTypeofModule.types index ef4238bf2c5..9b1b9b34832 100644 --- a/tests/baselines/reference/declFileTypeofModule.types +++ b/tests/baselines/reference/declFileTypeofModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofModule.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js index da1ebb2a8f3..ae82eec4714 100644 --- a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js +++ b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js @@ -1,5 +1,4 @@ //// [declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts] - declare module A.B.Base { export class W { id: number; diff --git a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols index dd591277cd3..f7d08619255 100644 --- a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols +++ b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols @@ -1,56 +1,55 @@ === tests/cases/compiler/declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts === - declare module A.B.Base { >A : Symbol(A, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 0)) ->B : Symbol(B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 17)) ->Base : Symbol(Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 19)) +>B : Symbol(B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 17)) +>Base : Symbol(Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 19)) export class W { ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 25)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 25)) id: number; ->id : Symbol(W.id, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 2, 20)) +>id : Symbol(W.id, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 20)) } } module X.Y.base { ->X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 11, 1)) ->Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) +>X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 4, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 10, 1)) +>Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) export class W extends A.B.Base.W { ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 17)) ->A.B.Base.W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 25)) ->A.B.Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 19)) ->A.B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 17)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 17)) +>A.B.Base.W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 25)) +>A.B.Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 19)) +>A.B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 17)) >A : Symbol(A, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 0)) ->B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 17)) ->Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 19)) ->W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 25)) +>B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 17)) +>Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 19)) +>W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 25)) name: string; ->name : Symbol(W.name, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 8, 39)) +>name : Symbol(W.name, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 7, 39)) } } module X.Y.base.Z { ->X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 11, 1)) ->Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) ->Z : Symbol(Z, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 16)) +>X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 4, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 10, 1)) +>Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) +>Z : Symbol(Z, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 16)) export class W extends X.Y.base.W { ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 19)) ->TValue : Symbol(TValue, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 15, 19)) ->X.Y.base.W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 17)) ->X.Y.base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) ->X.Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 11, 1)) ->Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 17)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 19)) +>TValue : Symbol(TValue, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 14, 19)) +>X.Y.base.W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 17)) +>X.Y.base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) +>X.Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 4, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 10, 1)) +>Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 17)) value: boolean; ->value : Symbol(W.value, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 15, 47)) +>value : Symbol(W.value, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 14, 47)) } } diff --git a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types index f032ad29b11..339e8d7e157 100644 --- a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types +++ b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts === - declare module A.B.Base { >A : typeof A >B : typeof B diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt index 97013301618..0cf59ee035b 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt @@ -1,7 +1,7 @@ +tests/cases/compiler/declFile.d.ts(2,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. tests/cases/compiler/declFile.d.ts(3,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(4,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(6,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(5,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(7,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. ==== tests/cases/compiler/client.ts (0 errors) ==== @@ -9,7 +9,6 @@ tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cann var x = new M.C(); // Declaration file wont get emitted because there are errors in declaration file ==== tests/cases/compiler/declFile.d.ts (4 errors) ==== - declare module M { declare var x; ~~~~~~~ diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js index 30e80ef4e6f..a615e155849 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileWithErrorsInInputDeclarationFile.ts] //// //// [declFile.d.ts] - declare module M { declare var x; declare function f(); diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt index 97013301618..0cf59ee035b 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt @@ -1,7 +1,7 @@ +tests/cases/compiler/declFile.d.ts(2,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. tests/cases/compiler/declFile.d.ts(3,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(4,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(6,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(5,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(7,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. ==== tests/cases/compiler/client.ts (0 errors) ==== @@ -9,7 +9,6 @@ tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cann var x = new M.C(); // Declaration file wont get emitted because there are errors in declaration file ==== tests/cases/compiler/declFile.d.ts (4 errors) ==== - declare module M { declare var x; ~~~~~~~ diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js index 99dd625760f..4ca4455ceb5 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileWithErrorsInInputDeclarationFileWithOut.ts] //// //// [declFile.d.ts] - declare module M { declare var x; declare function f(); diff --git a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js index d369da3902b..95ec6eeab32 100644 --- a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js +++ b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js @@ -1,5 +1,4 @@ //// [declFileWithExtendsClauseThatHasItsContainerNameConflict.ts] - declare module A.B.C { class B { } diff --git a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols index 552a4a44b35..125da03de55 100644 --- a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols +++ b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/declFileWithExtendsClauseThatHasItsContainerNameConflict.ts === - declare module A.B.C { ->A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 4, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 11, 1)) ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 9)) ->C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 11)) +>A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 3, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 10, 1)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 9)) +>C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 11)) class B { ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 22)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 22)) } } module A.B { ->A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 4, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 11, 1)) ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 9)) +>A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 3, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 10, 1)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 9)) export class EventManager { ->EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 12)) +>EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 12)) id: number; ->id : Symbol(EventManager.id, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 7, 31)) +>id : Symbol(EventManager.id, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 31)) } } module A.B.C { ->A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 4, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 11, 1)) ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 9)) ->C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 11)) +>A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 3, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 10, 1)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 9)) +>C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 11)) export class ContextMenu extends EventManager { ->ContextMenu : Symbol(ContextMenu, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 14)) ->EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 12)) +>ContextMenu : Symbol(ContextMenu, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 14)) +>EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 12)) name: string; ->name : Symbol(ContextMenu.name, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 14, 51)) +>name : Symbol(ContextMenu.name, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 51)) } } diff --git a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types index 4dae0d42c53..7564543097b 100644 --- a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types +++ b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithExtendsClauseThatHasItsContainerNameConflict.ts === - declare module A.B.C { >A : typeof A >B : typeof B diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js index 9b69ca88dc2..7b169027320 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js @@ -1,5 +1,4 @@ //// [declFileWithInternalModuleNameConflictsInExtendsClause1.ts] - module X.A.C { export interface Z { } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols index 15e9c6c6e85..05110ee99ef 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause1.ts === - module X.A.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 11)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 3, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 11)) export interface Z { ->Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 14)) +>Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 3, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 13)) module A { ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 16)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 16)) } export class W implements X.A.C.Z { // This needs to be refered as X.A.C.Z as A has conflict ->W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 7, 5)) ->X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 14)) ->X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 11)) ->X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 11)) ->Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 14)) +>W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 6, 5)) +>X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 14)) +>X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 11)) +>X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 3, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 11)) +>Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 14)) } } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types index f6fb6dae297..929f1ade1bf 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause1.ts === - module X.A.C { >X : typeof X >A : typeof A diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js index aa44c19444a..b2dce928df7 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js @@ -1,5 +1,4 @@ //// [declFileWithInternalModuleNameConflictsInExtendsClause2.ts] - module X.A.C { export interface Z { } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols index f0ce1ff2f97..3f716ab0472 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.ts === - module X.A.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 11)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 11)) export interface Z { ->Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 14)) +>Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 13)) export class W implements A.C.Z { // This can refer to it as A.C.Z ->W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 16)) ->A.C.Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 14)) ->A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 11)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 11)) ->Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 14)) +>W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 16)) +>A.C.Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 14)) +>A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 11)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 11)) +>Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 13)) module A { ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 16)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 16)) } } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types index a59a6930743..a244e2139e9 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.ts === - module X.A.C { >X : typeof X >A : typeof A diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js index 164626db45a..debc55565a1 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js @@ -1,5 +1,4 @@ //// [declFileWithInternalModuleNameConflictsInExtendsClause3.ts] - module X.A.C { export interface Z { } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols index 6d2a63b86ca..e077f2a1170 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.ts === - module X.A.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 11)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 11)) export interface Z { ->Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 14)) +>Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 13)) export class W implements X.A.C.Z { // This needs to be refered as X.A.C.Z as A has conflict ->W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 16)) ->X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 14)) ->X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 11)) ->X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 11)) ->Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 14)) +>W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 16)) +>X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 14)) +>X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 11)) +>X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 11)) +>Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 13)) export module A { ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 16)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 16)) } } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types index f263cd96af8..c94b408c939 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.ts === - module X.A.C { >X : typeof X >A : typeof A diff --git a/tests/baselines/reference/declarationEmitBindingPatterns.js b/tests/baselines/reference/declarationEmitBindingPatterns.js index c55d885a1ca..800e30032c6 100644 --- a/tests/baselines/reference/declarationEmitBindingPatterns.js +++ b/tests/baselines/reference/declarationEmitBindingPatterns.js @@ -1,5 +1,4 @@ //// [declarationEmitBindingPatterns.ts] - const k = ({x: z = 'y'}) => { } var a; diff --git a/tests/baselines/reference/declarationEmitBindingPatterns.symbols b/tests/baselines/reference/declarationEmitBindingPatterns.symbols index 705610bf04f..b3e011c16da 100644 --- a/tests/baselines/reference/declarationEmitBindingPatterns.symbols +++ b/tests/baselines/reference/declarationEmitBindingPatterns.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/declarationEmitBindingPatterns.ts === - const k = ({x: z = 'y'}) => { } ->k : Symbol(k, Decl(declarationEmitBindingPatterns.ts, 1, 5)) +>k : Symbol(k, Decl(declarationEmitBindingPatterns.ts, 0, 5)) >x : Symbol(x) ->z : Symbol(z, Decl(declarationEmitBindingPatterns.ts, 1, 12)) +>z : Symbol(z, Decl(declarationEmitBindingPatterns.ts, 0, 12)) var a; ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(declarationEmitBindingPatterns.ts, 3, 6)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) +>f : Symbol(f, Decl(declarationEmitBindingPatterns.ts, 2, 6)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) } diff --git a/tests/baselines/reference/declarationEmitBindingPatterns.types b/tests/baselines/reference/declarationEmitBindingPatterns.types index a0ae3f5aa14..1a47fbebf07 100644 --- a/tests/baselines/reference/declarationEmitBindingPatterns.types +++ b/tests/baselines/reference/declarationEmitBindingPatterns.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitBindingPatterns.ts === - const k = ({x: z = 'y'}) => { } >k : ({x: z}: { x?: string; }) => void >({x: z = 'y'}) => { } : ({x: z}: { x?: string; }) => void diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict.js b/tests/baselines/reference/declarationEmitClassMemberNameConflict.js index 698622a8650..200ca70d79f 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict.js +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict.js @@ -1,5 +1,4 @@ //// [declarationEmitClassMemberNameConflict.ts] - export class C1 { C1() { } // has to be the same as the class name diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols b/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols index 02ea2f015f3..d9cfd379f3d 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict.ts === - export class C1 { >C1 : Symbol(C1, Decl(declarationEmitClassMemberNameConflict.ts, 0, 0)) C1() { } // has to be the same as the class name ->C1 : Symbol(C1.C1, Decl(declarationEmitClassMemberNameConflict.ts, 1, 17)) +>C1 : Symbol(C1.C1, Decl(declarationEmitClassMemberNameConflict.ts, 0, 17)) bar() { ->bar : Symbol(C1.bar, Decl(declarationEmitClassMemberNameConflict.ts, 2, 12)) +>bar : Symbol(C1.bar, Decl(declarationEmitClassMemberNameConflict.ts, 1, 12)) return function (t: typeof C1) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 5, 25)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 4, 25)) >C1 : Symbol(C1, Decl(declarationEmitClassMemberNameConflict.ts, 0, 0)) }; @@ -18,52 +17,52 @@ export class C1 { } export class C2 { ->C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 8, 1)) +>C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 7, 1)) C2: any // has to be the same as the class name ->C2 : Symbol(C2.C2, Decl(declarationEmitClassMemberNameConflict.ts, 10, 17)) +>C2 : Symbol(C2.C2, Decl(declarationEmitClassMemberNameConflict.ts, 9, 17)) bar() { ->bar : Symbol(C2.bar, Decl(declarationEmitClassMemberNameConflict.ts, 11, 11)) +>bar : Symbol(C2.bar, Decl(declarationEmitClassMemberNameConflict.ts, 10, 11)) return function (t: typeof C2) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 14, 25)) ->C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 8, 1)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 13, 25)) +>C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 7, 1)) }; } } export class C3 { ->C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 17, 1)) +>C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 16, 1)) get C3() { return 0; } // has to be the same as the class name ->C3 : Symbol(C3.C3, Decl(declarationEmitClassMemberNameConflict.ts, 19, 17)) +>C3 : Symbol(C3.C3, Decl(declarationEmitClassMemberNameConflict.ts, 18, 17)) bar() { ->bar : Symbol(C3.bar, Decl(declarationEmitClassMemberNameConflict.ts, 20, 26)) +>bar : Symbol(C3.bar, Decl(declarationEmitClassMemberNameConflict.ts, 19, 26)) return function (t: typeof C3) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 23, 25)) ->C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 17, 1)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 22, 25)) +>C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 16, 1)) }; } } export class C4 { ->C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 26, 1)) +>C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 25, 1)) set C4(v) { } // has to be the same as the class name ->C4 : Symbol(C4.C4, Decl(declarationEmitClassMemberNameConflict.ts, 28, 17)) ->v : Symbol(v, Decl(declarationEmitClassMemberNameConflict.ts, 29, 11)) +>C4 : Symbol(C4.C4, Decl(declarationEmitClassMemberNameConflict.ts, 27, 17)) +>v : Symbol(v, Decl(declarationEmitClassMemberNameConflict.ts, 28, 11)) bar() { ->bar : Symbol(C4.bar, Decl(declarationEmitClassMemberNameConflict.ts, 29, 17)) +>bar : Symbol(C4.bar, Decl(declarationEmitClassMemberNameConflict.ts, 28, 17)) return function (t: typeof C4) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 32, 25)) ->C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 26, 1)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 31, 25)) +>C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 25, 1)) }; } diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict.types b/tests/baselines/reference/declarationEmitClassMemberNameConflict.types index 266942f29c5..ab83212d0eb 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict.types +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict.ts === - export class C1 { >C1 : C1 diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js index c5f8203a659..34ed145b6f3 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js @@ -1,5 +1,4 @@ //// [declarationEmitClassMemberNameConflict2.ts] - const Bar = 'bar'; enum Hello { diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols index 059200c6074..096ac556f94 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict2.ts === - const Bar = 'bar'; ->Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 5)) +>Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 5)) enum Hello { ->Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 18)) +>Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 18)) World ->World : Symbol(Hello.World, Decl(declarationEmitClassMemberNameConflict2.ts, 3, 12)) +>World : Symbol(Hello.World, Decl(declarationEmitClassMemberNameConflict2.ts, 2, 12)) } enum Hello1 { ->Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 5, 1)) +>Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 4, 1)) World1 ->World1 : Symbol(Hello1.World1, Decl(declarationEmitClassMemberNameConflict2.ts, 7, 13)) +>World1 : Symbol(Hello1.World1, Decl(declarationEmitClassMemberNameConflict2.ts, 6, 13)) } class Foo { ->Foo : Symbol(Foo, Decl(declarationEmitClassMemberNameConflict2.ts, 9, 1)) +>Foo : Symbol(Foo, Decl(declarationEmitClassMemberNameConflict2.ts, 8, 1)) // Same names + string => OK Bar = Bar; ->Bar : Symbol(Foo.Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 11, 11)) ->Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 5)) +>Bar : Symbol(Foo.Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 10, 11)) +>Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 5)) // Same names + enum => OK Hello = Hello; ->Hello : Symbol(Foo.Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 13, 14)) ->Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 18)) +>Hello : Symbol(Foo.Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 12, 14)) +>Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 18)) // Different names + enum => OK Hello2 = Hello1; ->Hello2 : Symbol(Foo.Hello2, Decl(declarationEmitClassMemberNameConflict2.ts, 16, 18)) ->Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 5, 1)) +>Hello2 : Symbol(Foo.Hello2, Decl(declarationEmitClassMemberNameConflict2.ts, 15, 18)) +>Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 4, 1)) } diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types index f355a9002c8..ede64818ff5 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict2.ts === - const Bar = 'bar'; >Bar : "bar" >'bar' : "bar" diff --git a/tests/baselines/reference/declarationEmitDefaultExport8.js b/tests/baselines/reference/declarationEmitDefaultExport8.js index c023f3be7d3..5511c5981e5 100644 --- a/tests/baselines/reference/declarationEmitDefaultExport8.js +++ b/tests/baselines/reference/declarationEmitDefaultExport8.js @@ -1,5 +1,4 @@ //// [declarationEmitDefaultExport8.ts] - var _default = 1; export {_default as d} export default 1 + 2; diff --git a/tests/baselines/reference/declarationEmitDefaultExport8.symbols b/tests/baselines/reference/declarationEmitDefaultExport8.symbols index be886b5a289..b5bf1beaa9e 100644 --- a/tests/baselines/reference/declarationEmitDefaultExport8.symbols +++ b/tests/baselines/reference/declarationEmitDefaultExport8.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/declarationEmitDefaultExport8.ts === - var _default = 1; ->_default : Symbol(_default, Decl(declarationEmitDefaultExport8.ts, 1, 3)) +>_default : Symbol(_default, Decl(declarationEmitDefaultExport8.ts, 0, 3)) export {_default as d} ->_default : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 2, 8)) ->d : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 2, 8)) +>_default : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 1, 8)) +>d : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 1, 8)) export default 1 + 2; diff --git a/tests/baselines/reference/declarationEmitDefaultExport8.types b/tests/baselines/reference/declarationEmitDefaultExport8.types index ed66a0fcb6f..54de7b9839e 100644 --- a/tests/baselines/reference/declarationEmitDefaultExport8.types +++ b/tests/baselines/reference/declarationEmitDefaultExport8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDefaultExport8.ts === - var _default = 1; >_default : number >1 : 1 diff --git a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js index 6b16d06cb84..6ac6cf29018 100644 --- a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js +++ b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js @@ -1,5 +1,4 @@ //// [pi.ts] - export default 3.14159; //// [app.js] diff --git a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols index 82f52e818e3..a45ecb2e47e 100644 --- a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols +++ b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols @@ -1,4 +1,3 @@ === tests/cases/compiler/pi.ts === - -No type information for this code.export default 3.14159; +export default 3.14159; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types index 82f52e818e3..a45ecb2e47e 100644 --- a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types +++ b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types @@ -1,4 +1,3 @@ === tests/cases/compiler/pi.ts === - -No type information for this code.export default 3.14159; +export default 3.14159; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js index 9a9be8c69da..6bd118e8f1c 100644 --- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js +++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringArrayPattern1.ts] - var [] = [1, "hello"]; // Dont emit anything var [x] = [1, "hello"]; // emit x: number var [x1, y1] = [1, "hello"]; // emit x1: number, y1: string diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols index e9d80c89f6e..8c954cb0d25 100644 --- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols +++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/declarationEmitDestructuringArrayPattern1.ts === - var [] = [1, "hello"]; // Dont emit anything var [x] = [1, "hello"]; // emit x: number ->x : Symbol(x, Decl(declarationEmitDestructuringArrayPattern1.ts, 2, 5)) +>x : Symbol(x, Decl(declarationEmitDestructuringArrayPattern1.ts, 1, 5)) var [x1, y1] = [1, "hello"]; // emit x1: number, y1: string ->x1 : Symbol(x1, Decl(declarationEmitDestructuringArrayPattern1.ts, 3, 5)) ->y1 : Symbol(y1, Decl(declarationEmitDestructuringArrayPattern1.ts, 3, 8)) +>x1 : Symbol(x1, Decl(declarationEmitDestructuringArrayPattern1.ts, 2, 5)) +>y1 : Symbol(y1, Decl(declarationEmitDestructuringArrayPattern1.ts, 2, 8)) var [, , z1] = [0, 1, 2]; // emit z1: number ->z1 : Symbol(z1, Decl(declarationEmitDestructuringArrayPattern1.ts, 4, 8)) +>z1 : Symbol(z1, Decl(declarationEmitDestructuringArrayPattern1.ts, 3, 8)) var a = [1, "hello"]; ->a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 3)) +>a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 5, 3)) var [x2] = a; // emit x2: number | string ->x2 : Symbol(x2, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 5)) ->a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 3)) +>x2 : Symbol(x2, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 5)) +>a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 5, 3)) var [x3, y3, z3] = a; // emit x3, y3, z3 ->x3 : Symbol(x3, Decl(declarationEmitDestructuringArrayPattern1.ts, 8, 5)) ->y3 : Symbol(y3, Decl(declarationEmitDestructuringArrayPattern1.ts, 8, 8)) ->z3 : Symbol(z3, Decl(declarationEmitDestructuringArrayPattern1.ts, 8, 12)) ->a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 3)) +>x3 : Symbol(x3, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 5)) +>y3 : Symbol(y3, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 8)) +>z3 : Symbol(z3, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 12)) +>a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 5, 3)) diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types index 640062c0785..c52b9893463 100644 --- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types +++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDestructuringArrayPattern1.ts === - var [] = [1, "hello"]; // Dont emit anything >[1, "hello"] : (string | number)[] >1 : 1 diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt index 92a8cba2d40..63b68a6fc6b 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(2,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(2,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(3,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(4,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(6,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(7,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(1,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(1,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. ==== tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts (6 errors) ==== - var { } = { x: 5, y: "hello" }; ~ !!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js index 38b0a14af5c..0414017b776 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringObjectLiteralPattern.ts] - var { } = { x: 5, y: "hello" }; var { x4 } = { x4: 5, y4: "hello" }; var { y5 } = { x5: 5, y5: "hello" }; diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt index 24fbcf99ad1..bb8ec829b35 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(2,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(2,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(3,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(4,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(6,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(7,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(1,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(1,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. ==== tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts (6 errors) ==== - var { } = { x: 5, y: "hello" }; ~ !!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js index 264e56fe58c..1e8279597d5 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringObjectLiteralPattern1.ts] - var { } = { x: 5, y: "hello" }; var { x4 } = { x4: 5, y4: "hello" }; var { y5 } = { x5: 5, y5: "hello" }; diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js index 7e5a3d9d2fa..6b8add193f2 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringObjectLiteralPattern2.ts] - var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; function f15() { diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols index 77e26e2c9b7..2138ef896e0 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols @@ -1,49 +1,48 @@ === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern2.ts === - var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 46)) ->x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 5)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 52)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 57)) ->y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 18)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 69)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 74)) ->z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 31)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 46)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 52)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 57)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 69)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 74)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 46)) +>x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 5)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 52)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 57)) +>y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 18)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 69)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 74)) +>z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 31)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 46)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 52)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 57)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 69)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 74)) function f15() { ->f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 89)) +>f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 89)) var a4 = "hello"; ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 4, 7)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 3, 7)) var b4 = 1; ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 5, 7)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 4, 7)) var c4 = true; ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 7)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 5, 7)) return { a4, b4, c4 }; ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 12)) ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 16)) ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 20)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 12)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 16)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 20)) } var { a4, b4, c4 } = f15(); ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 5)) ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 9)) ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 13)) ->f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 89)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 5)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 9)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 13)) +>f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 89)) module m { ->m : Symbol(m, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 27)) +>m : Symbol(m, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 27)) export var { a4, b4, c4 } = f15(); ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 12, 16)) ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 12, 20)) ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 12, 24)) ->f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 89)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 11, 16)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 11, 20)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 11, 24)) +>f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 89)) } diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types index f8f9a6a319c..a86976c0d1f 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern2.ts === - var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; >a : any >x11 : number diff --git a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js index 941bb383f81..c64148f8e50 100644 --- a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js +++ b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringOptionalBindingParametersInOverloads.ts] - function foo([x, y, z] ?: [string, number, boolean]); function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols index fbe26452476..1cfe2b72e87 100644 --- a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols +++ b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/declarationEmitDestructuringOptionalBindingParametersInOverloads.ts === - function foo([x, y, z] ?: [string, number, boolean]); ->foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 53)) ->x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 14)) ->y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 16)) ->z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 19)) +>foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 53)) +>x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 14)) +>y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 16)) +>z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 19)) function foo(...rest: any[]) { ->foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 53)) ->rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 2, 13)) +>foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 53)) +>rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 13)) } function foo2( { x, y, z }?: { x: string; y: number; z: boolean }); ->foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 3, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 67)) ->x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 16)) ->y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 19)) ->z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 22)) ->x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 30)) ->y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 41)) ->z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 52)) +>foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 2, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 67)) +>x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 16)) +>y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 19)) +>z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 22)) +>x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 30)) +>y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 41)) +>z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 52)) function foo2(...rest: any[]) { ->foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 3, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 67)) ->rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 6, 14)) +>foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 2, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 67)) +>rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 14)) } diff --git a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types index 9eabfebe877..0bf290bcf7d 100644 --- a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types +++ b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDestructuringOptionalBindingParametersInOverloads.ts === - function foo([x, y, z] ?: [string, number, boolean]); >foo : ([x, y, z]?: [string, number, boolean]) => any >x : string diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.js b/tests/baselines/reference/declarationEmitDetachedComment1.js index 6d3666d389d..7f3bcea93c8 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment1.js +++ b/tests/baselines/reference/declarationEmitDetachedComment1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitDetachedComment1.ts] //// //// [test1.ts] - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.symbols b/tests/baselines/reference/declarationEmitDetachedComment1.symbols index c466716ca44..509c64c87db 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment1.symbols +++ b/tests/baselines/reference/declarationEmitDetachedComment1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.types b/tests/baselines/reference/declarationEmitDetachedComment1.types index 6d1a87b5151..26b72fd4983 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment1.types +++ b/tests/baselines/reference/declarationEmitDetachedComment1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.js b/tests/baselines/reference/declarationEmitDetachedComment2.js index e06872b5eab..0874733e532 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment2.js +++ b/tests/baselines/reference/declarationEmitDetachedComment2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitDetachedComment2.ts] //// //// [test1.ts] - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.symbols b/tests/baselines/reference/declarationEmitDetachedComment2.symbols index c466716ca44..509c64c87db 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment2.symbols +++ b/tests/baselines/reference/declarationEmitDetachedComment2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.types b/tests/baselines/reference/declarationEmitDetachedComment2.types index 6d1a87b5151..26b72fd4983 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment2.types +++ b/tests/baselines/reference/declarationEmitDetachedComment2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitExportAssignment.js b/tests/baselines/reference/declarationEmitExportAssignment.js index 223376ef8ff..371e586f4d9 100644 --- a/tests/baselines/reference/declarationEmitExportAssignment.js +++ b/tests/baselines/reference/declarationEmitExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitExportAssignment.ts] //// //// [utils.ts] - export function foo() { } export function bar() { } export interface Buzz { } diff --git a/tests/baselines/reference/declarationEmitExportAssignment.symbols b/tests/baselines/reference/declarationEmitExportAssignment.symbols index d2131d27a8f..f03ce547dbb 100644 --- a/tests/baselines/reference/declarationEmitExportAssignment.symbols +++ b/tests/baselines/reference/declarationEmitExportAssignment.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : Symbol(foo, Decl(utils.ts, 0, 0)) export function bar() { } ->bar : Symbol(bar, Decl(utils.ts, 1, 25)) +>bar : Symbol(bar, Decl(utils.ts, 0, 25)) export interface Buzz { } ->Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25)) +>Buzz : Symbol(Buzz, Decl(utils.ts, 1, 25)) === tests/cases/compiler/index.ts === import {foo} from "./utils"; diff --git a/tests/baselines/reference/declarationEmitExportAssignment.types b/tests/baselines/reference/declarationEmitExportAssignment.types index 763441b8a90..ee8db1950f2 100644 --- a/tests/baselines/reference/declarationEmitExportAssignment.types +++ b/tests/baselines/reference/declarationEmitExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : () => void diff --git a/tests/baselines/reference/declarationEmitExportDeclaration.js b/tests/baselines/reference/declarationEmitExportDeclaration.js index 57c39b95e64..1cde34aeba0 100644 --- a/tests/baselines/reference/declarationEmitExportDeclaration.js +++ b/tests/baselines/reference/declarationEmitExportDeclaration.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitExportDeclaration.ts] //// //// [utils.ts] - export function foo() { } export function bar() { } export interface Buzz { } diff --git a/tests/baselines/reference/declarationEmitExportDeclaration.symbols b/tests/baselines/reference/declarationEmitExportDeclaration.symbols index 40d6bafdee5..3a63171377e 100644 --- a/tests/baselines/reference/declarationEmitExportDeclaration.symbols +++ b/tests/baselines/reference/declarationEmitExportDeclaration.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : Symbol(foo, Decl(utils.ts, 0, 0)) export function bar() { } ->bar : Symbol(bar, Decl(utils.ts, 1, 25)) +>bar : Symbol(bar, Decl(utils.ts, 0, 25)) export interface Buzz { } ->Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25)) +>Buzz : Symbol(Buzz, Decl(utils.ts, 1, 25)) === tests/cases/compiler/index.ts === import {foo, bar, Buzz} from "./utils"; diff --git a/tests/baselines/reference/declarationEmitExportDeclaration.types b/tests/baselines/reference/declarationEmitExportDeclaration.types index 25a8f1d29bd..1e52215aef3 100644 --- a/tests/baselines/reference/declarationEmitExportDeclaration.types +++ b/tests/baselines/reference/declarationEmitExportDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : () => void diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends.js b/tests/baselines/reference/declarationEmitExpressionInExtends.js index 884897a9cf6..2c659ce9018 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends.ts] - var x: { new(s: any): Q; } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends.symbols b/tests/baselines/reference/declarationEmitExpressionInExtends.symbols index 8ae1e2928fd..157c82dd4ca 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends.symbols +++ b/tests/baselines/reference/declarationEmitExpressionInExtends.symbols @@ -1,32 +1,31 @@ === tests/cases/compiler/declarationEmitExpressionInExtends.ts === - var x: { ->x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 1, 3)) +>x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 0, 3)) new(s: any): Q; ->T : Symbol(T, Decl(declarationEmitExpressionInExtends.ts, 2, 8)) ->s : Symbol(s, Decl(declarationEmitExpressionInExtends.ts, 2, 11)) ->Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 3, 1)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends.ts, 1, 8)) +>s : Symbol(s, Decl(declarationEmitExpressionInExtends.ts, 1, 11)) +>Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 2, 1)) } class Q { ->Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 3, 1)) +>Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 2, 1)) s: string; ->s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 5, 9)) +>s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 4, 9)) } class B extends x { ->B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 7, 1)) ->x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 1, 3)) +>B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 6, 1)) +>x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 0, 3)) } var q: B; ->q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 12, 3)) ->B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 7, 1)) +>q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 11, 3)) +>B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 6, 1)) q.s; ->q.s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 5, 9)) ->q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 12, 3)) ->s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 5, 9)) +>q.s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 4, 9)) +>q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 11, 3)) +>s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 4, 9)) diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends.types b/tests/baselines/reference/declarationEmitExpressionInExtends.types index fdbec3f9c48..a11312e225f 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends.types +++ b/tests/baselines/reference/declarationEmitExpressionInExtends.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitExpressionInExtends.ts === - var x: { >x : new (s: any) => Q diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends2.js b/tests/baselines/reference/declarationEmitExpressionInExtends2.js index 86c79dda8a8..301d935a1db 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends2.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends2.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends2.ts] - class C { x: T; y: U; diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols b/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols index a07590a14c7..28a6308d115 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols +++ b/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/declarationEmitExpressionInExtends2.ts === - class C { >C : Symbol(C, Decl(declarationEmitExpressionInExtends2.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 1, 8)) ->U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 1, 10)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 0, 8)) +>U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 0, 10)) x: T; ->x : Symbol(C.x, Decl(declarationEmitExpressionInExtends2.ts, 1, 15)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 1, 8)) +>x : Symbol(C.x, Decl(declarationEmitExpressionInExtends2.ts, 0, 15)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 0, 8)) y: U; ->y : Symbol(C.y, Decl(declarationEmitExpressionInExtends2.ts, 2, 9)) ->U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 1, 10)) +>y : Symbol(C.y, Decl(declarationEmitExpressionInExtends2.ts, 1, 9)) +>U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 0, 10)) } function getClass(c: T) { ->getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 4, 1)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 6, 18)) ->c : Symbol(c, Decl(declarationEmitExpressionInExtends2.ts, 6, 21)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 6, 18)) +>getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 3, 1)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 5, 18)) +>c : Symbol(c, Decl(declarationEmitExpressionInExtends2.ts, 5, 21)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 5, 18)) return C; >C : Symbol(C, Decl(declarationEmitExpressionInExtends2.ts, 0, 0)) } class MyClass extends getClass(2) { ->MyClass : Symbol(MyClass, Decl(declarationEmitExpressionInExtends2.ts, 8, 1)) ->getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 4, 1)) +>MyClass : Symbol(MyClass, Decl(declarationEmitExpressionInExtends2.ts, 7, 1)) +>getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 3, 1)) } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends2.types b/tests/baselines/reference/declarationEmitExpressionInExtends2.types index 04265e9f74e..435c0e8dbf8 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends2.types +++ b/tests/baselines/reference/declarationEmitExpressionInExtends2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitExpressionInExtends2.ts === - class C { >C : C >T : T diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt b/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt index 8bc4d9ac8d2..636085215ac 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt +++ b/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/declarationEmitExpressionInExtends3.ts(29,30): error TS4020: 'extends' clause of exported class 'MyClass' has or is using private name 'LocalClass'. -tests/cases/compiler/declarationEmitExpressionInExtends3.ts(37,31): error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'. +tests/cases/compiler/declarationEmitExpressionInExtends3.ts(28,30): error TS4020: 'extends' clause of exported class 'MyClass' has or is using private name 'LocalClass'. +tests/cases/compiler/declarationEmitExpressionInExtends3.ts(36,31): error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'. ==== tests/cases/compiler/declarationEmitExpressionInExtends3.ts (2 errors) ==== - export class ExportedClass { x: T; } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends3.js b/tests/baselines/reference/declarationEmitExpressionInExtends3.js index a02eac46dba..7cc58772ec2 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends3.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends3.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends3.ts] - export class ExportedClass { x: T; } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt b/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt index 127f71ff353..b2e3eb58d54 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt +++ b/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt @@ -1,14 +1,13 @@ -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(2,10): error TS4060: Return type of exported function has or is using private name 'D'. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(6,7): error TS4093: 'extends' clause of exported class 'C' refers to a type whose name cannot be referenced. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(6,17): error TS2315: Type 'D' is not generic. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(10,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(10,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(15,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(15,18): error TS4020: 'extends' clause of exported class 'C3' has or is using private name 'SomeUndefinedFunction'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(1,10): error TS4060: Return type of exported function has or is using private name 'D'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,7): error TS4093: 'extends' clause of exported class 'C' refers to a type whose name cannot be referenced. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,17): error TS2315: Type 'D' is not generic. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(9,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(9,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(14,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(14,18): error TS4020: 'extends' clause of exported class 'C3' has or is using private name 'SomeUndefinedFunction'. ==== tests/cases/compiler/declarationEmitExpressionInExtends4.ts (7 errors) ==== - function getSomething() { ~~~~~~~~~~~~ !!! error TS4060: Return type of exported function has or is using private name 'D'. diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends4.js b/tests/baselines/reference/declarationEmitExpressionInExtends4.js index d6c33023c12..4acfff77831 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends4.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends4.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends4.ts] - function getSomething() { return class D { } } diff --git a/tests/baselines/reference/declarationEmitFBoundedTypeParams.js b/tests/baselines/reference/declarationEmitFBoundedTypeParams.js index 407dbf395e5..056ed423d5c 100644 --- a/tests/baselines/reference/declarationEmitFBoundedTypeParams.js +++ b/tests/baselines/reference/declarationEmitFBoundedTypeParams.js @@ -1,5 +1,4 @@ //// [declarationEmitFBoundedTypeParams.ts] - // Repro from #6040 function append(result: a[], value: b): a[] { diff --git a/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols b/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols index bb12ea89600..b90516af3b1 100644 --- a/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols +++ b/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/declarationEmitFBoundedTypeParams.ts === - // Repro from #6040 function append(result: a[], value: b): a[] { >append : Symbol(append, Decl(declarationEmitFBoundedTypeParams.ts, 0, 0)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) ->b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 3, 18)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) ->result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 3, 32)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) ->value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 3, 44)) ->b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 3, 18)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) +>b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 2, 18)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) +>result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 2, 32)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) +>value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 2, 44)) +>b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 2, 18)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) result.push(value); >result.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 3, 32)) +>result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 2, 32)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 3, 44)) +>value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 2, 44)) return result; ->result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 3, 32)) +>result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 2, 32)) } diff --git a/tests/baselines/reference/declarationEmitFBoundedTypeParams.types b/tests/baselines/reference/declarationEmitFBoundedTypeParams.types index 7f7198b3b6d..80d1c80855d 100644 --- a/tests/baselines/reference/declarationEmitFBoundedTypeParams.types +++ b/tests/baselines/reference/declarationEmitFBoundedTypeParams.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitFBoundedTypeParams.ts === - // Repro from #6040 function append(result: a[], value: b): a[] { diff --git a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js index b2bca641a5a..327a0befe6a 100644 --- a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js +++ b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js @@ -1,5 +1,4 @@ //// [declarationEmitFirstTypeArgumentGenericFunctionType.ts] - class X { } var prop11: X< () => Tany >; // spaces before the first type argument diff --git a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols index ebbc2b764b0..d820821dbdd 100644 --- a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols +++ b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols @@ -1,81 +1,80 @@ === tests/cases/compiler/declarationEmitFirstTypeArgumentGenericFunctionType.ts === - class X { >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 1, 8)) +>A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 8)) } var prop11: X< () => Tany >; // spaces before the first type argument ->prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) +>prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 3)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 16)) var prop12: X<(() => Tany)>; // spaces before the first type argument ->prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 3)) +>prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 16)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) function f1() { // Inferred return type ->f1 : Symbol(f1, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 34)) +>f1 : Symbol(f1, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 34)) return prop11; ->prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) +>prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 3)) } function f2() { // Inferred return type ->f2 : Symbol(f2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 7, 1)) +>f2 : Symbol(f2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 6, 1)) return prop12; ->prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 3)) +>prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) } function f3(): X< () => Tany> { // written with space before type argument ->f3 : Symbol(f3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 10, 1)) +>f3 : Symbol(f3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 9, 1)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 11, 19)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 11, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 10, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 10, 19)) return prop11; ->prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) +>prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 3)) } function f4(): X<(() => Tany)> { // written type with parenthesis ->f4 : Symbol(f4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 13, 1)) +>f4 : Symbol(f4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 12, 1)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 14, 19)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 14, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 13, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 13, 19)) return prop12; ->prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 3)) +>prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) } class Y { ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 17, 8)) ->B : Symbol(B, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 17, 10)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 8)) +>B : Symbol(B, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 10)) } var prop2: Y() => Tany>; // No space after second type argument ->prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) +>prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 24)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 24)) var prop2: Y() => Tany>; // space after second type argument ->prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 24)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 24)) +>prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) var prop3: Y< () => Tany, () => Tany>; // space before first type argument ->prop3 : Symbol(prop3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 33)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 33)) +>prop3 : Symbol(prop3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 33)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 33)) var prop4: Y<(() => Tany), () => Tany>; // parenthesized first type argument ->prop4 : Symbol(prop4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 34)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 34)) +>prop4 : Symbol(prop4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 34)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 34)) diff --git a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types index 4dd6ecba987..6fbff14492c 100644 --- a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types +++ b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitFirstTypeArgumentGenericFunctionType.ts === - class X { >X : X >A : A diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicates01.js b/tests/baselines/reference/declarationEmitIdentifierPredicates01.js index 08208c2435d..5bf62608fb8 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicates01.js +++ b/tests/baselines/reference/declarationEmitIdentifierPredicates01.js @@ -1,5 +1,4 @@ //// [declarationEmitIdentifierPredicates01.ts] - export function f(x: any): x is number { return typeof x === "number"; } diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols b/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols index eb8b1151ceb..5078fccedbc 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols +++ b/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicates01.ts === - export function f(x: any): x is number { >f : Symbol(f, Decl(declarationEmitIdentifierPredicates01.ts, 0, 0)) ->x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 1, 18)) ->x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 1, 18)) +>x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 0, 18)) +>x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 0, 18)) return typeof x === "number"; ->x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 1, 18)) +>x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 0, 18)) } diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicates01.types b/tests/baselines/reference/declarationEmitIdentifierPredicates01.types index 1aeb3ea824d..6699e3fa234 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicates01.types +++ b/tests/baselines/reference/declarationEmitIdentifierPredicates01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicates01.ts === - export function f(x: any): x is number { >f : (x: any) => x is number >x : any diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt index e9084c45490..37a4853b649 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt +++ b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicatesWithPrivateName01.ts(6,33): error TS4060: Return type of exported function has or is using private name 'I'. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicatesWithPrivateName01.ts(5,33): error TS4060: Return type of exported function has or is using private name 'I'. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicatesWithPrivateName01.ts (1 errors) ==== - interface I { a: number; } diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js index 5829e9b4427..74da01ce683 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js +++ b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js @@ -1,5 +1,4 @@ //// [declarationEmitIdentifierPredicatesWithPrivateName01.ts] - interface I { a: number; } diff --git a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js index a60b35c73ab..f9137f4f02b 100644 --- a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js +++ b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js @@ -1,5 +1,4 @@ //// [declarationEmitImportInExportAssignmentModule.ts] - module m { export module c { export class c { diff --git a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols index c4c92d547f3..8abdc855d8e 100644 --- a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols +++ b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declarationEmitImportInExportAssignmentModule.ts === - module m { >m : Symbol(m, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 0)) export module c { ->c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 1, 10)) +>c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 10)) export class c { ->c : Symbol(c, Decl(declarationEmitImportInExportAssignmentModule.ts, 2, 21)) +>c : Symbol(c, Decl(declarationEmitImportInExportAssignmentModule.ts, 1, 21)) } } import x = c; ->x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 5, 5)) ->c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 1, 10)) +>x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 4, 5)) +>c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 10)) export var a: typeof x; ->a : Symbol(a, Decl(declarationEmitImportInExportAssignmentModule.ts, 7, 14)) ->x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 5, 5)) +>a : Symbol(a, Decl(declarationEmitImportInExportAssignmentModule.ts, 6, 14)) +>x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 4, 5)) } export = m; >m : Symbol(m, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types index 23176a0abe2..8cf124a92ce 100644 --- a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types +++ b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitImportInExportAssignmentModule.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt b/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt index ffbfd25fa94..435ddd7c069 100644 --- a/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt +++ b/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(3,6): error TS1023: An index signature parameter type must be 'string' or 'number'. -tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(3,13): error TS2304: Cannot find name 'TypeNotFound'. -tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(3,13): error TS4092: Parameter 'index' of index signature from exported interface has or is using private name 'TypeNotFound'. +tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(2,6): error TS1023: An index signature parameter type must be 'string' or 'number'. +tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(2,13): error TS2304: Cannot find name 'TypeNotFound'. +tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(2,13): error TS4092: Parameter 'index' of index signature from exported interface has or is using private name 'TypeNotFound'. ==== tests/cases/compiler/declarationEmitIndexTypeNotFound.ts (3 errors) ==== - export interface Test { [index: TypeNotFound]: any; ~~~~~ diff --git a/tests/baselines/reference/declarationEmitIndexTypeNotFound.js b/tests/baselines/reference/declarationEmitIndexTypeNotFound.js index b1fac7c3cc2..f28f33f88e6 100644 --- a/tests/baselines/reference/declarationEmitIndexTypeNotFound.js +++ b/tests/baselines/reference/declarationEmitIndexTypeNotFound.js @@ -1,5 +1,4 @@ //// [declarationEmitIndexTypeNotFound.ts] - export interface Test { [index: TypeNotFound]: any; } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType.js b/tests/baselines/reference/declarationEmitInferedDefaultExportType.js index 608f172cd1f..4d9eb47641a 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType.js +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedDefaultExportType.ts] - // test.ts export default { foo: [], diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols b/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols index bf96810f78a..5d49c84e8f8 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType.ts === - // test.ts export default { foo: [], ->foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType.ts, 2, 16)) +>foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType.ts, 1, 16)) bar: undefined, ->bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType.ts, 3, 10)) +>bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType.ts, 2, 10)) >undefined : Symbol(undefined) baz: null ->baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType.ts, 4, 17)) +>baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType.ts, 3, 17)) } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType.types b/tests/baselines/reference/declarationEmitInferedDefaultExportType.types index 5c01d22b32e..4ccb520b606 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType.types +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType.ts === - // test.ts export default { >{ foo: [], bar: undefined, baz: null} : { foo: undefined[]; bar: undefined; baz: null; } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js index a81c7fc0bb7..96c16829d7e 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedDefaultExportType2.ts] - // test.ts export = { foo: [], diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols index 7ae974cca05..8a617715bf4 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType2.ts === - // test.ts export = { foo: [], ->foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType2.ts, 2, 10)) +>foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType2.ts, 1, 10)) bar: undefined, ->bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType2.ts, 3, 10)) +>bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType2.ts, 2, 10)) >undefined : Symbol(undefined) baz: null ->baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType2.ts, 4, 17)) +>baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType2.ts, 3, 17)) } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types index a334434ea45..808a0cf1e85 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType2.ts === - // test.ts export = { >{ foo: [], bar: undefined, baz: null} : { foo: undefined[]; bar: undefined; baz: null; } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.js b/tests/baselines/reference/declarationEmitInferedTypeAlias1.js index 4e41c8558c6..091e7f97a0e 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias1.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias1.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols index 94599418c5d..3f49ebf17f7 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.types b/tests/baselines/reference/declarationEmitInferedTypeAlias1.types index 922eb9ccf44..7ea5f6ff228 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias1.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.js b/tests/baselines/reference/declarationEmitInferedTypeAlias2.js index 601026ab6f3..d99a1abc346 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias2.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias2.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols index c8027397869..6494c8d8e82 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.types b/tests/baselines/reference/declarationEmitInferedTypeAlias2.types index 6a9ace4eb86..058c57a5c03 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias2.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.js b/tests/baselines/reference/declarationEmitInferedTypeAlias3.js index 30df7e38b01..4621aa8db2f 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias3.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias3.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols index 8a9f7b35d18..916ce781a28 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.types b/tests/baselines/reference/declarationEmitInferedTypeAlias3.types index 565a484a094..aa8fcf9eae1 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias3.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.js b/tests/baselines/reference/declarationEmitInferedTypeAlias4.js index 8d7ef72012c..c29dbb517d9 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias4.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedTypeAlias4.ts] - function f() { type Foo = T | { x: Foo }; var x: Foo; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols index f522eca7d0b..6108e2326d0 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias4.ts === - function f() { >f : Symbol(f, Decl(declarationEmitInferedTypeAlias4.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11)) +>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 0, 11)) type Foo = T | { x: Foo }; ->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13)) ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 23)) ->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13)) +>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 1, 23)) +>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13)) var x: Foo; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7)) ->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17)) ->A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 7)) +>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17)) +>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 0, 11)) return x; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 7)) } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.types b/tests/baselines/reference/declarationEmitInferedTypeAlias4.types index f4cc0789f45..b4e5428e82a 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias4.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias4.ts === - function f() { >f : () => A[] | { x: A[] | any; } >A : A diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.js b/tests/baselines/reference/declarationEmitInferedTypeAlias5.js index 24f2a52c5d8..a20c4da52e0 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias5.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias5.ts] //// //// [0.ts] - export type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols index 6c06697cfdc..8c904c87c9b 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Symbol(Data, Decl(0.ts, 0, 0)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 2, 3)) +>obj : Symbol(obj, Decl(0.ts, 1, 3)) >Data : Symbol(Data, Decl(0.ts, 0, 0)) === tests/cases/compiler/1.ts === diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.types b/tests/baselines/reference/declarationEmitInferedTypeAlias5.types index 21e6b415d2e..d6d3ae7443e 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias5.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Data diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.js b/tests/baselines/reference/declarationEmitInferedTypeAlias6.js index 5b14a3738e4..0b98e0bdeb0 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias6.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias6.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols index 94599418c5d..3f49ebf17f7 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.types b/tests/baselines/reference/declarationEmitInferedTypeAlias6.types index 922eb9ccf44..7ea5f6ff228 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias6.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.js b/tests/baselines/reference/declarationEmitInferedTypeAlias7.js index 9a9b1247e24..187913b0fd8 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias7.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias7.ts] //// //// [0.ts] - export type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols index 8923fd72692..90a0e6f975a 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Symbol(Data, Decl(0.ts, 0, 0)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 2, 3)) +>obj : Symbol(obj, Decl(0.ts, 1, 3)) >Data : Symbol(Data, Decl(0.ts, 0, 0)) === tests/cases/compiler/1.ts === diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.types b/tests/baselines/reference/declarationEmitInferedTypeAlias7.types index f4bcaaf5105..72289ce63dd 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias7.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Data diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.js b/tests/baselines/reference/declarationEmitInferedTypeAlias8.js index 54a8ba37af1..d6e3c6bb7c2 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias8.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedTypeAlias8.ts] - type Foo = T | { x: Foo }; var x: Foo; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols index 9a0c0974e79..3e4b21c4a06 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias8.ts === - type Foo = T | { x: Foo }; >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9)) ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 19)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 0, 19)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9)) var x: Foo; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 3)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0)) function returnSomeGlobalValue() { ->returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 2, 21)) +>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 1, 21)) return x; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 3)) } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.types b/tests/baselines/reference/declarationEmitInferedTypeAlias8.types index 9fc0aaf7016..c58624aad56 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias8.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias8.ts === - type Foo = T | { x: Foo }; >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.js b/tests/baselines/reference/declarationEmitInferedTypeAlias9.js index cddb4630740..3f237f2dc44 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias9.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedTypeAlias9.ts] - type Foo = T | { x: Foo }; var x: Foo; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols index 5057ef22c0b..3a147cd63a2 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias9.ts === - type Foo = T | { x: Foo }; >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9)) ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 19)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 0, 19)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9)) var x: Foo; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 3)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0)) export function returnSomeGlobalValue() { ->returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 2, 21)) +>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 1, 21)) return x; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 3)) } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.types b/tests/baselines/reference/declarationEmitInferedTypeAlias9.types index d4f61bf927a..b49c5c49887 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias9.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias9.ts === - type Foo = T | { x: Foo }; >Foo : T | { x: T | any; } >T : T diff --git a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt index 7dc3a70fdc7..fa504d6cb0a 100644 --- a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt +++ b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts(3,25): error TS2499: An interface can only extend an identifier/qualified-name with optional type arguments. +tests/cases/compiler/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts(2,25): error TS2499: An interface can only extend an identifier/qualified-name with optional type arguments. ==== tests/cases/compiler/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts (1 errors) ==== - class A { } interface Class extends (typeof A) { } ~~~~~~~~~~ diff --git a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js index ef2d2e479b0..fc50955c4e5 100644 --- a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js +++ b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js @@ -1,5 +1,4 @@ //// [declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts] - class A { } interface Class extends (typeof A) { } diff --git a/tests/baselines/reference/declarationEmitInvalidExport.errors.txt b/tests/baselines/reference/declarationEmitInvalidExport.errors.txt index 529a6167973..74c8fc6b0a5 100644 --- a/tests/baselines/reference/declarationEmitInvalidExport.errors.txt +++ b/tests/baselines/reference/declarationEmitInvalidExport.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/declarationEmitInvalidExport.ts(3,3): error TS7027: Unreachable code detected. -tests/cases/compiler/declarationEmitInvalidExport.ts(5,30): error TS4081: Exported type alias 'MyClass' has or is using private name 'myClass'. -tests/cases/compiler/declarationEmitInvalidExport.ts(6,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/declarationEmitInvalidExport.ts(2,3): error TS7027: Unreachable code detected. +tests/cases/compiler/declarationEmitInvalidExport.ts(4,30): error TS4081: Exported type alias 'MyClass' has or is using private name 'myClass'. +tests/cases/compiler/declarationEmitInvalidExport.ts(5,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/declarationEmitInvalidExport.ts (3 errors) ==== - if (false) { export var myClass = 0; ~~~~~~ diff --git a/tests/baselines/reference/declarationEmitInvalidExport.js b/tests/baselines/reference/declarationEmitInvalidExport.js index d4280cd00c6..be71312b98e 100644 --- a/tests/baselines/reference/declarationEmitInvalidExport.js +++ b/tests/baselines/reference/declarationEmitInvalidExport.js @@ -1,5 +1,4 @@ //// [declarationEmitInvalidExport.ts] - if (false) { export var myClass = 0; } diff --git a/tests/baselines/reference/declarationEmitPromise.js b/tests/baselines/reference/declarationEmitPromise.js index 7444a956a2a..5ed52f8af4c 100644 --- a/tests/baselines/reference/declarationEmitPromise.js +++ b/tests/baselines/reference/declarationEmitPromise.js @@ -1,5 +1,4 @@ //// [declarationEmitPromise.ts] - export class bluebird { static all: Array>; } diff --git a/tests/baselines/reference/declarationEmitPromise.symbols b/tests/baselines/reference/declarationEmitPromise.symbols index 2c37e1dfa78..6a57f3dcd0d 100644 --- a/tests/baselines/reference/declarationEmitPromise.symbols +++ b/tests/baselines/reference/declarationEmitPromise.symbols @@ -1,155 +1,154 @@ === tests/cases/compiler/declarationEmitPromise.ts === - export class bluebird { >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 1, 22)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 0, 22)) static all: Array>; ->all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) } export async function runSampleWorks( ->runSampleWorks : Symbol(runSampleWorks, Decl(declarationEmitPromise.ts, 3, 1)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 5, 37)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 5, 39)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 5, 42)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 5, 45)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 5, 48)) +>runSampleWorks : Symbol(runSampleWorks, Decl(declarationEmitPromise.ts, 2, 1)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 4, 37)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 4, 39)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 4, 42)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 4, 45)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 4, 48)) a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird) { ->a : Symbol(a, Decl(declarationEmitPromise.ts, 5, 52)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 4, 52)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 5, 37)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 6, 19)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 4, 37)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 5, 19)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 5, 39)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 6, 36)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 4, 39)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 5, 36)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 5, 42)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 6, 53)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 4, 42)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 5, 53)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 5, 45)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 6, 70)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 4, 45)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 5, 70)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 5, 48)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 4, 48)) let result = await (bluebird.all as any)([a, b, c, d, e].filter(el => !!el)); ->result : Symbol(result, Decl(declarationEmitPromise.ts, 7, 7)) ->bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 6, 7)) +>bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 5, 52)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 6, 19)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 6, 36)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 6, 53)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 6, 70)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 4, 52)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 5, 19)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 5, 36)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 5, 53)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 5, 70)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 7, 68)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 7, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68)) let func = (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T): T => ->func : Symbol(func, Decl(declarationEmitPromise.ts, 8, 7)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 8, 16)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 8, 19)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 8, 23)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 5, 37)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 8, 28)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 5, 39)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 8, 35)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 5, 42)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 8, 42)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 5, 45)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 8, 49)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 5, 48)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 8, 16)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 8, 16)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 7, 7)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 7, 19)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 7, 23)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 4, 37)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 7, 28)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 4, 39)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 7, 35)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 4, 42)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 7, 42)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 4, 45)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 7, 49)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 4, 48)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16)) f.apply(this, result); >f.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 8, 19)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 7, 19)) >apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(declarationEmitPromise.ts, 7, 7)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 6, 7)) let rfunc: typeof func & {} = func as any; // <- This is the only difference ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 10, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 8, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 8, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 9, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 7, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 7, 7)) return rfunc ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 10, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 9, 7)) } export async function runSampleBreaks( ->runSampleBreaks : Symbol(runSampleBreaks, Decl(declarationEmitPromise.ts, 12, 1)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 14, 38)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 14, 40)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 14, 43)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 14, 46)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 14, 49)) +>runSampleBreaks : Symbol(runSampleBreaks, Decl(declarationEmitPromise.ts, 11, 1)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 13, 38)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 13, 40)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 13, 43)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 13, 46)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 13, 49)) a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird) { ->a : Symbol(a, Decl(declarationEmitPromise.ts, 14, 53)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 13, 53)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 14, 38)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 15, 19)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 13, 38)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 14, 19)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 14, 40)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 15, 36)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 13, 40)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 14, 36)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 14, 43)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 15, 53)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 13, 43)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 14, 53)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 14, 46)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 15, 70)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 13, 46)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 14, 70)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 14, 49)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 13, 49)) let result = await (bluebird.all as any)([a, b, c, d, e].filter(el => !!el)); ->result : Symbol(result, Decl(declarationEmitPromise.ts, 16, 7)) ->bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 15, 7)) +>bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 14, 53)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 15, 19)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 15, 36)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 15, 53)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 15, 70)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 13, 53)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 14, 19)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 14, 36)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 14, 53)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 14, 70)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 16, 68)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 16, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68)) let func = (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T): T => ->func : Symbol(func, Decl(declarationEmitPromise.ts, 17, 7)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 17, 16)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 17, 19)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 17, 23)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 14, 38)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 17, 28)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 14, 40)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 17, 35)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 14, 43)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 17, 42)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 14, 46)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 17, 49)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 14, 49)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 17, 16)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 17, 16)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 16, 7)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 16, 19)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 16, 23)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 13, 38)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 16, 28)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 13, 40)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 16, 35)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 13, 43)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 16, 42)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 13, 46)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 16, 49)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 13, 49)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16)) f.apply(this, result); >f.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 17, 19)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 16, 19)) >apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(declarationEmitPromise.ts, 16, 7)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 15, 7)) let rfunc: typeof func = func as any; // <- This is the only difference ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 19, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 17, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 17, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 18, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 16, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 16, 7)) return rfunc ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 19, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 18, 7)) } diff --git a/tests/baselines/reference/declarationEmitPromise.types b/tests/baselines/reference/declarationEmitPromise.types index 4edaa444326..64c4e30cde3 100644 --- a/tests/baselines/reference/declarationEmitPromise.types +++ b/tests/baselines/reference/declarationEmitPromise.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitPromise.ts === - export class bluebird { >bluebird : bluebird >T : T diff --git a/tests/baselines/reference/declarationEmitProtectedMembers.js b/tests/baselines/reference/declarationEmitProtectedMembers.js index 7b3b42e7c97..a31d74fbbb1 100644 --- a/tests/baselines/reference/declarationEmitProtectedMembers.js +++ b/tests/baselines/reference/declarationEmitProtectedMembers.js @@ -1,5 +1,4 @@ //// [declarationEmitProtectedMembers.ts] - // Class with protected members class C1 { protected x: number; diff --git a/tests/baselines/reference/declarationEmitProtectedMembers.symbols b/tests/baselines/reference/declarationEmitProtectedMembers.symbols index 31f1a9a67e4..189e9a418fb 100644 --- a/tests/baselines/reference/declarationEmitProtectedMembers.symbols +++ b/tests/baselines/reference/declarationEmitProtectedMembers.symbols @@ -1,114 +1,113 @@ === tests/cases/compiler/declarationEmitProtectedMembers.ts === - // Class with protected members class C1 { >C1 : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) protected x: number; ->x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) protected f() { ->f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 3, 24)) +>f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 2, 24)) return this.x; ->this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) >this : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) } protected set accessor(a: number) { } ->accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 7, 5), Decl(declarationEmitProtectedMembers.ts, 9, 41)) ->a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 9, 27)) +>accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 6, 5), Decl(declarationEmitProtectedMembers.ts, 8, 41)) +>a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 8, 27)) protected get accessor() { return 0; } ->accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 7, 5), Decl(declarationEmitProtectedMembers.ts, 9, 41)) +>accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 6, 5), Decl(declarationEmitProtectedMembers.ts, 8, 41)) protected static sx: number; ->sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) protected static sf() { ->sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 12, 32)) +>sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 11, 32)) return this.sx; ->this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) >this : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) } protected static set staticSetter(a: number) { } ->staticSetter : Symbol(C1.staticSetter, Decl(declarationEmitProtectedMembers.ts, 16, 5)) ->a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 18, 38)) +>staticSetter : Symbol(C1.staticSetter, Decl(declarationEmitProtectedMembers.ts, 15, 5)) +>a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 17, 38)) protected static get staticGetter() { return 0; } ->staticGetter : Symbol(C1.staticGetter, Decl(declarationEmitProtectedMembers.ts, 18, 52)) +>staticGetter : Symbol(C1.staticGetter, Decl(declarationEmitProtectedMembers.ts, 17, 52)) } // Derived class overriding protected members class C2 extends C1 { ->C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) +>C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) >C1 : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) protected f() { ->f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 23, 21)) +>f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 22, 21)) return super.f() + this.x; ->super.f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 3, 24)) +>super.f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 2, 24)) >super : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 3, 24)) ->this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) ->this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 2, 24)) +>this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) +>this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) } protected static sf() { ->sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 26, 5)) +>sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 25, 5)) return super.sf() + this.sx; ->super.sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 12, 32)) +>super.sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 11, 32)) >super : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 12, 32)) ->this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) ->this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 11, 32)) +>this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) +>this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) } } // Derived class making protected members public class C3 extends C2 { ->C3 : Symbol(C3, Decl(declarationEmitProtectedMembers.ts, 30, 1)) ->C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) +>C3 : Symbol(C3, Decl(declarationEmitProtectedMembers.ts, 29, 1)) +>C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) x: number; ->x : Symbol(C3.x, Decl(declarationEmitProtectedMembers.ts, 33, 21)) +>x : Symbol(C3.x, Decl(declarationEmitProtectedMembers.ts, 32, 21)) static sx: number; ->sx : Symbol(C3.sx, Decl(declarationEmitProtectedMembers.ts, 34, 14)) +>sx : Symbol(C3.sx, Decl(declarationEmitProtectedMembers.ts, 33, 14)) f() { ->f : Symbol(C3.f, Decl(declarationEmitProtectedMembers.ts, 35, 22)) +>f : Symbol(C3.f, Decl(declarationEmitProtectedMembers.ts, 34, 22)) return super.f(); ->super.f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 23, 21)) ->super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 23, 21)) +>super.f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 22, 21)) +>super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 22, 21)) } static sf() { ->sf : Symbol(C3.sf, Decl(declarationEmitProtectedMembers.ts, 38, 5)) +>sf : Symbol(C3.sf, Decl(declarationEmitProtectedMembers.ts, 37, 5)) return super.sf(); ->super.sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 26, 5)) ->super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 26, 5)) +>super.sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 25, 5)) +>super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 25, 5)) } static get staticGetter() { return 1; } ->staticGetter : Symbol(C3.staticGetter, Decl(declarationEmitProtectedMembers.ts, 41, 5)) +>staticGetter : Symbol(C3.staticGetter, Decl(declarationEmitProtectedMembers.ts, 40, 5)) } // Protected properties in constructors class C4 { ->C4 : Symbol(C4, Decl(declarationEmitProtectedMembers.ts, 44, 1)) +>C4 : Symbol(C4, Decl(declarationEmitProtectedMembers.ts, 43, 1)) constructor(protected a: number, protected b) { } ->a : Symbol(C4.a, Decl(declarationEmitProtectedMembers.ts, 48, 16)) ->b : Symbol(C4.b, Decl(declarationEmitProtectedMembers.ts, 48, 36)) +>a : Symbol(C4.a, Decl(declarationEmitProtectedMembers.ts, 47, 16)) +>b : Symbol(C4.b, Decl(declarationEmitProtectedMembers.ts, 47, 36)) } diff --git a/tests/baselines/reference/declarationEmitProtectedMembers.types b/tests/baselines/reference/declarationEmitProtectedMembers.types index b293487d57d..ea3dfdae8bb 100644 --- a/tests/baselines/reference/declarationEmitProtectedMembers.types +++ b/tests/baselines/reference/declarationEmitProtectedMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitProtectedMembers.ts === - // Class with protected members class C1 { >C1 : C1 diff --git a/tests/baselines/reference/declarationEmitReadonly.js b/tests/baselines/reference/declarationEmitReadonly.js index fd90188940c..4a3a80523ba 100644 --- a/tests/baselines/reference/declarationEmitReadonly.js +++ b/tests/baselines/reference/declarationEmitReadonly.js @@ -1,5 +1,4 @@ //// [declarationEmitReadonly.ts] - class C { constructor(readonly x: number) {} } diff --git a/tests/baselines/reference/declarationEmitReadonly.symbols b/tests/baselines/reference/declarationEmitReadonly.symbols index 2ef310cf7df..04c9277e96f 100644 --- a/tests/baselines/reference/declarationEmitReadonly.symbols +++ b/tests/baselines/reference/declarationEmitReadonly.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/classes/constructorDeclarations/constructorParameters/declarationEmitReadonly.ts === - class C { >C : Symbol(C, Decl(declarationEmitReadonly.ts, 0, 0)) constructor(readonly x: number) {} ->x : Symbol(C.x, Decl(declarationEmitReadonly.ts, 2, 16)) +>x : Symbol(C.x, Decl(declarationEmitReadonly.ts, 1, 16)) } diff --git a/tests/baselines/reference/declarationEmitReadonly.types b/tests/baselines/reference/declarationEmitReadonly.types index e64256698cf..5d2a69325e1 100644 --- a/tests/baselines/reference/declarationEmitReadonly.types +++ b/tests/baselines/reference/declarationEmitReadonly.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/constructorDeclarations/constructorParameters/declarationEmitReadonly.ts === - class C { >C : C diff --git a/tests/baselines/reference/declarationEmitThisPredicates01.js b/tests/baselines/reference/declarationEmitThisPredicates01.js index e95a7db05ed..70ed3147a9e 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates01.js +++ b/tests/baselines/reference/declarationEmitThisPredicates01.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicates01.ts] - export class C { m(): this is D { return this instanceof D; diff --git a/tests/baselines/reference/declarationEmitThisPredicates01.symbols b/tests/baselines/reference/declarationEmitThisPredicates01.symbols index af5da751b8c..221caece23e 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates01.symbols +++ b/tests/baselines/reference/declarationEmitThisPredicates01.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates01.ts === - export class C { >C : Symbol(C, Decl(declarationEmitThisPredicates01.ts, 0, 0)) m(): this is D { ->m : Symbol(C.m, Decl(declarationEmitThisPredicates01.ts, 1, 16)) ->D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 5, 1)) +>m : Symbol(C.m, Decl(declarationEmitThisPredicates01.ts, 0, 16)) +>D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 4, 1)) return this instanceof D; >this : Symbol(C, Decl(declarationEmitThisPredicates01.ts, 0, 0)) ->D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 5, 1)) +>D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 4, 1)) } } export class D extends C { ->D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 5, 1)) +>D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 4, 1)) >C : Symbol(C, Decl(declarationEmitThisPredicates01.ts, 0, 0)) } diff --git a/tests/baselines/reference/declarationEmitThisPredicates01.types b/tests/baselines/reference/declarationEmitThisPredicates01.types index 9d801a40965..486bf64b2f5 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates01.types +++ b/tests/baselines/reference/declarationEmitThisPredicates01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates01.ts === - export class C { >C : C diff --git a/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt b/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt index 4d95cf01136..308b130e908 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt +++ b/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates02.ts(9,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates02.ts(8,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates02.ts (1 errors) ==== - export interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitThisPredicates02.js b/tests/baselines/reference/declarationEmitThisPredicates02.js index 0e7c99df1f3..f1d814d3461 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates02.js +++ b/tests/baselines/reference/declarationEmitThisPredicates02.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicates02.ts] - export interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt index 67c76283f80..ea59c8fa9e8 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName01.ts(3,18): error TS4055: Return type of public method from exported class has or is using private name 'D'. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName01.ts(2,18): error TS4055: Return type of public method from exported class has or is using private name 'D'. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName01.ts (1 errors) ==== - export class C { m(): this is D { ~ diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js index a0f611d2d29..e7c4c9998b9 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicatesWithPrivateName01.ts] - export class C { m(): this is D { return this instanceof D; diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt index 86c0f478133..20c8cef3a43 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(8,14): error TS4025: Exported variable 'obj' has or is using private name 'Foo'. -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(9,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(7,14): error TS4025: Exported variable 'obj' has or is using private name 'Foo'. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(8,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts (2 errors) ==== - interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js index 7ec7ba5dec8..ba8e7a1cda4 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicatesWithPrivateName02.ts] - interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt index af0bcad47fa..4b32bba9bbd 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt +++ b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(2,18): error TS2304: Cannot find name 'Unknown'. -tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(2,18): error TS4083: Type parameter 'T' of exported type alias has or is using private name 'Unknown'. +tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(1,18): error TS2304: Cannot find name 'Unknown'. +tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(1,18): error TS4083: Type parameter 'T' of exported type alias has or is using private name 'Unknown'. ==== tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts (2 errors) ==== - type A = {} ~~~~~~~ !!! error TS2304: Cannot find name 'Unknown'. diff --git a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js index eedcc6eccb7..2cfb8b4f6b0 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js +++ b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts] - type A = {} //// [declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js] diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js index 84b55a9792f..d2110bea4fe 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters1.ts] - export type Bar = () => [X, Y]; export type Foo = Bar; export const y = (x: Foo) => 1 diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols index fa63e711f9a..2499c403b9b 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters1.ts === - export type Bar = () => [X, Y]; >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 0)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 18)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 18)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 18)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 18)) export type Foo = Bar; ->Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 37)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 16)) +>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 37)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 0)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) export const y = (x: Foo) => 1 ->y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 3, 12)) ->x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 3, 18)) ->Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 37)) +>y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 12)) +>x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 18)) +>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 37)) diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types index a8b0f146f8e..eda63988994 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters1.ts === - export type Bar = () => [X, Y]; >Bar : Bar >X : X diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js index 1bb6beac9e1..5c76056ac62 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters2.ts] - export type Bar = () => [X, Y, Z]; export type Baz = Bar; export type Baa = Baz; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols index cc13e9fd30b..af4197f5e37 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts === - export type Bar = () => [X, Y, Z]; >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) ->Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) ->Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 18)) +>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 21)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 18)) +>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 21)) export type Baz = Bar; ->Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43)) ->M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) ->N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18)) +>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 43)) +>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) +>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0)) ->M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) ->N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18)) +>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) +>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) export type Baa = Baz; ->Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16)) ->Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16)) +>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 42)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) +>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 43)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) export const y = (x: Baa) => 1 ->y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 12)) ->x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 18)) ->Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42)) +>y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 12)) +>x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 18)) +>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 42)) diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types index 74becc49765..fbf51858af8 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts === - export type Bar = () => [X, Y, Z]; >Bar : Bar >X : X diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js index 9e2a366a685..0cb7e23c4c5 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters3.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols index a18b1372cf1..b524c052c95 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts === - type Foo = { >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 9)) +>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 9)) foo(): Foo ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 15)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 15)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 8)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 8)) }; function bar() { ->bar : Symbol(bar, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 3, 2)) +>bar : Symbol(bar, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 2)) return {} as Foo; >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types index 1b2ff140178..b57b3743f74 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts === - type Foo = { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js index 26908d915e0..c3365029136 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters4.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols index de73f544645..6a94160c663 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts === - type Foo = { >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 9)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 11)) +>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 9)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 11)) foo(): Foo ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 18)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 18)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 10)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 10)) }; type SubFoo = Foo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 2)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 12)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 12)) function foo() { ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 32)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 32)) return {} as SubFoo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 2)) } diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types index c545ac6bb05..7272e1189ac 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts === - type Foo = { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt index 7f683dcc7b7..9552adfc0af 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts(5,25): error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'. +tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts(4,25): error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'. ==== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts (1 errors) ==== - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js index 28997a75496..cee701c0455 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters5.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js index c8001446e3e..a8e7dc8ca18 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters6.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols index ec29989f078..47769eb8727 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts === - type Foo = { >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 9)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 11)) +>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 9)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 11)) foo(): Foo ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 18)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 18)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 10)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 10)) }; type SubFoo = Foo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12)) ->S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 2)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 12)) +>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 14)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0)) ->S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12)) +>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 14)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 12)) function foo() { ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 30)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 30)) return {} as SubFoo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 2)) } diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types index b02ccbc2be7..59b5984d20e 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts === - type Foo = { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitUnknownImport.errors.txt b/tests/baselines/reference/declarationEmitUnknownImport.errors.txt index a2bee225fe8..13b124d2bfe 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport.errors.txt +++ b/tests/baselines/reference/declarationEmitUnknownImport.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/declarationEmitUnknownImport.ts(2,14): error TS2304: Cannot find name 'SomeNonExistingName'. -tests/cases/compiler/declarationEmitUnknownImport.ts(2,14): error TS2503: Cannot find namespace 'SomeNonExistingName'. -tests/cases/compiler/declarationEmitUnknownImport.ts(2,14): error TS4000: Import declaration 'Foo' is using private name 'SomeNonExistingName'. +tests/cases/compiler/declarationEmitUnknownImport.ts(1,14): error TS2304: Cannot find name 'SomeNonExistingName'. +tests/cases/compiler/declarationEmitUnknownImport.ts(1,14): error TS2503: Cannot find namespace 'SomeNonExistingName'. +tests/cases/compiler/declarationEmitUnknownImport.ts(1,14): error TS4000: Import declaration 'Foo' is using private name 'SomeNonExistingName'. ==== tests/cases/compiler/declarationEmitUnknownImport.ts (3 errors) ==== - import Foo = SomeNonExistingName ~~~~~~~~~~~~~~~~~~~ !!! error TS2304: Cannot find name 'SomeNonExistingName'. diff --git a/tests/baselines/reference/declarationEmitUnknownImport.js b/tests/baselines/reference/declarationEmitUnknownImport.js index 1ac1e934578..6755c1e2b2b 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport.js +++ b/tests/baselines/reference/declarationEmitUnknownImport.js @@ -1,5 +1,4 @@ //// [declarationEmitUnknownImport.ts] - import Foo = SomeNonExistingName export {Foo} diff --git a/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt b/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt index db017d3c89a..71494859728 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt +++ b/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS1005: '=' expected. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS2304: Cannot find name 'From'. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS2503: Cannot find namespace 'From'. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS4000: Import declaration 'Foo' is using private name 'From'. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,17): error TS1005: ';' expected. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS1005: '=' expected. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS2304: Cannot find name 'From'. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS2503: Cannot find namespace 'From'. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS4000: Import declaration 'Foo' is using private name 'From'. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,17): error TS1005: ';' expected. ==== tests/cases/compiler/declarationEmitUnknownImport2.ts (5 errors) ==== - import Foo From './Foo'; // Syntax error ~~~~ !!! error TS1005: '=' expected. diff --git a/tests/baselines/reference/declarationEmitUnknownImport2.js b/tests/baselines/reference/declarationEmitUnknownImport2.js index 1f291312913..2d34c869fe6 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport2.js +++ b/tests/baselines/reference/declarationEmitUnknownImport2.js @@ -1,5 +1,4 @@ //// [declarationEmitUnknownImport2.ts] - import Foo From './Foo'; // Syntax error export default Foo diff --git a/tests/baselines/reference/declarationFileOverwriteError.errors.txt b/tests/baselines/reference/declarationFileOverwriteError.errors.txt index 846f2387dc1..c25c56df926 100644 --- a/tests/baselines/reference/declarationFileOverwriteError.errors.txt +++ b/tests/baselines/reference/declarationFileOverwriteError.errors.txt @@ -5,7 +5,6 @@ error TS5055: Cannot write file 'tests/cases/compiler/a.d.ts' because it would o !!! error TS5055: Cannot write file 'tests/cases/compiler/a.d.ts' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/compiler/a.d.ts (0 errors) ==== - declare class c { } diff --git a/tests/baselines/reference/declarationFileOverwriteError.js b/tests/baselines/reference/declarationFileOverwriteError.js index 7bc57cce7d1..533cca55b22 100644 --- a/tests/baselines/reference/declarationFileOverwriteError.js +++ b/tests/baselines/reference/declarationFileOverwriteError.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFileOverwriteError.ts] //// //// [a.d.ts] - declare class c { } diff --git a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt index b3c9fd4780d..3e43a21f51d 100644 --- a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt +++ b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt @@ -5,7 +5,6 @@ error TS5055: Cannot write file 'tests/cases/compiler/out.d.ts' because it would !!! error TS5055: Cannot write file 'tests/cases/compiler/out.d.ts' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/compiler/out.d.ts (0 errors) ==== - declare class c { } diff --git a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js index 372d07f5ba7..72a5239b9a7 100644 --- a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js +++ b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFileOverwriteErrorWithOut.ts] //// //// [out.d.ts] - declare class c { } diff --git a/tests/baselines/reference/declarationFiles.errors.txt b/tests/baselines/reference/declarationFiles.errors.txt index bbd65b6d658..67a3e91bfb0 100644 --- a/tests/baselines/reference/declarationFiles.errors.txt +++ b/tests/baselines/reference/declarationFiles.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/types/thisType/declarationFiles.ts(5,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface. -tests/cases/conformance/types/thisType/declarationFiles.ts(31,5): error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary. -tests/cases/conformance/types/thisType/declarationFiles.ts(33,5): error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary. -tests/cases/conformance/types/thisType/declarationFiles.ts(35,5): error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary. -tests/cases/conformance/types/thisType/declarationFiles.ts(41,5): error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(4,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/declarationFiles.ts(30,5): error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(32,5): error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(34,5): error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(40,5): error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary. ==== tests/cases/conformance/types/thisType/declarationFiles.ts (5 errors) ==== - class C1 { x: this; f(x: this): this { return undefined; } diff --git a/tests/baselines/reference/declarationFiles.js b/tests/baselines/reference/declarationFiles.js index 56f44b2c7e4..7ee2f344ea1 100644 --- a/tests/baselines/reference/declarationFiles.js +++ b/tests/baselines/reference/declarationFiles.js @@ -1,5 +1,4 @@ //// [declarationFiles.ts] - class C1 { x: this; f(x: this): this { return undefined; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences1.js b/tests/baselines/reference/declarationFilesWithTypeReferences1.js index b4695f28f13..757fa4a7a37 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences1.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences1.js @@ -1,13 +1,11 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences1.ts] //// //// [index.d.ts] - interface Error { stack2: string; } //// [app.ts] - function foo(): Error { return undefined; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols index 3d3df3c1622..58f8534b492 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols @@ -1,14 +1,12 @@ === /node_modules/@types/node/index.d.ts === - interface Error { >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error.stack2, Decl(index.d.ts, 1, 17)) +>stack2 : Symbol(Error.stack2, Decl(index.d.ts, 0, 17)) } === /app.ts === - function foo(): Error { >foo : Symbol(foo, Decl(app.ts, 0, 0)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(index.d.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences1.types b/tests/baselines/reference/declarationFilesWithTypeReferences1.types index 7837b7b3a6c..4f7d980afc6 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences1.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences1.types @@ -1,5 +1,4 @@ === /node_modules/@types/node/index.d.ts === - interface Error { >Error : Error @@ -8,7 +7,6 @@ interface Error { } === /app.ts === - function foo(): Error { >foo : () => Error >Error : Error diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences2.js b/tests/baselines/reference/declarationFilesWithTypeReferences2.js index b85dcc45107..6852d90d594 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences2.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences2.js @@ -1,13 +1,11 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences2.ts] //// //// [index.d.ts] - interface Error2 { stack2: string; } //// [app.ts] - function foo(): Error2 { return undefined; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols index dc6d8a3a6de..2a64e8c42f8 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols @@ -1,14 +1,12 @@ === /node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Symbol(Error2, Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 1, 18)) +>stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 0, 18)) } === /app.ts === - function foo(): Error2 { >foo : Symbol(foo, Decl(app.ts, 0, 0)) >Error2 : Symbol(Error2, Decl(index.d.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences2.types b/tests/baselines/reference/declarationFilesWithTypeReferences2.types index c56f4ba6a67..3412d193fe1 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences2.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences2.types @@ -1,5 +1,4 @@ === /node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Error2 @@ -8,7 +7,6 @@ interface Error2 { } === /app.ts === - function foo(): Error2 { >foo : () => Error2 >Error2 : Error2 diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences3.js b/tests/baselines/reference/declarationFilesWithTypeReferences3.js index 3a18859c610..dafec09848f 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences3.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences3.ts] //// //// [index.d.ts] - interface Error2 { stack2: string; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols index 78335f988e9..fab7e5bbc06 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols @@ -1,10 +1,9 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Symbol(Error2, Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 1, 18)) +>stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 0, 18)) } === /a/app.ts === diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences3.types b/tests/baselines/reference/declarationFilesWithTypeReferences3.types index 9ac0105890a..98b9bc14df0 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences3.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences3.types @@ -1,5 +1,4 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Error2 diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences4.js b/tests/baselines/reference/declarationFilesWithTypeReferences4.js index b45860be9bb..1356c459c09 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences4.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences4.ts] //// //// [index.d.ts] - interface Error { stack2: string; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols index 216bd2a6a1c..f05bd814fc7 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols @@ -1,10 +1,9 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error { >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error.stack2, Decl(index.d.ts, 1, 17)) +>stack2 : Symbol(Error.stack2, Decl(index.d.ts, 0, 17)) } === /a/app.ts === diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences4.types b/tests/baselines/reference/declarationFilesWithTypeReferences4.types index 0ae603716b1..cce74d144ee 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences4.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences4.types @@ -1,5 +1,4 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error { >Error : Error diff --git a/tests/baselines/reference/declarationMerging2.js b/tests/baselines/reference/declarationMerging2.js index 64a6cf2d849..b360d9af3f7 100644 --- a/tests/baselines/reference/declarationMerging2.js +++ b/tests/baselines/reference/declarationMerging2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationMerging2.ts] //// //// [a.ts] - export class A { protected _f: number; getF() { return this._f; } diff --git a/tests/baselines/reference/declarationMerging2.symbols b/tests/baselines/reference/declarationMerging2.symbols index 050b5414da5..3a740300633 100644 --- a/tests/baselines/reference/declarationMerging2.symbols +++ b/tests/baselines/reference/declarationMerging2.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/a.ts === - export class A { >A : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 1, 22)) protected _f: number; ->_f : Symbol(A._f, Decl(a.ts, 1, 16)) +>_f : Symbol(A._f, Decl(a.ts, 0, 16)) getF() { return this._f; } ->getF : Symbol(A.getF, Decl(a.ts, 2, 25)) ->this._f : Symbol(A._f, Decl(a.ts, 1, 16)) +>getF : Symbol(A.getF, Decl(a.ts, 1, 25)) +>this._f : Symbol(A._f, Decl(a.ts, 0, 16)) >this : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 1, 22)) ->_f : Symbol(A._f, Decl(a.ts, 1, 16)) +>_f : Symbol(A._f, Decl(a.ts, 0, 16)) } === tests/cases/compiler/b.ts === diff --git a/tests/baselines/reference/declarationMerging2.types b/tests/baselines/reference/declarationMerging2.types index 79e2818cf52..3d30bf89904 100644 --- a/tests/baselines/reference/declarationMerging2.types +++ b/tests/baselines/reference/declarationMerging2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A { >A : A diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt index a46dfb0d339..b02b93e17b0 100644 --- a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt +++ b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt @@ -1,15 +1,13 @@ +tests/cases/conformance/classes/classDeclarations/file1.ts(1,15): error TS2300: Duplicate identifier 'C1'. tests/cases/conformance/classes/classDeclarations/file1.ts(3,15): error TS2300: Duplicate identifier 'C1'. -tests/cases/conformance/classes/classDeclarations/file1.ts(5,15): error TS2300: Duplicate identifier 'C1'. -tests/cases/conformance/classes/classDeclarations/file1.ts(7,15): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/file1.ts(9,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/file1.ts(11,15): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/file2.ts(2,15): error TS2300: Duplicate identifier 'C3'. -tests/cases/conformance/classes/classDeclarations/file3.ts(2,15): error TS2300: Duplicate identifier 'C3'. +tests/cases/conformance/classes/classDeclarations/file1.ts(5,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(7,11): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(9,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file2.ts(1,15): error TS2300: Duplicate identifier 'C3'. +tests/cases/conformance/classes/classDeclarations/file3.ts(1,15): error TS2300: Duplicate identifier 'C3'. ==== tests/cases/conformance/classes/classDeclarations/file1.ts (5 errors) ==== - - declare class C1 {} ~~ !!! error TS2300: Duplicate identifier 'C1'. @@ -31,13 +29,11 @@ tests/cases/conformance/classes/classDeclarations/file3.ts(2,15): error TS2300: !!! error TS2300: Duplicate identifier 'C2'. ==== tests/cases/conformance/classes/classDeclarations/file2.ts (1 errors) ==== - declare class C3 { } ~~ !!! error TS2300: Duplicate identifier 'C3'. ==== tests/cases/conformance/classes/classDeclarations/file3.ts (1 errors) ==== - declare class C3 { } ~~ !!! error TS2300: Duplicate identifier 'C3'. \ No newline at end of file diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.js b/tests/baselines/reference/declaredClassMergedwithSelf.js index a38391d90db..efbf93f59d6 100644 --- a/tests/baselines/reference/declaredClassMergedwithSelf.js +++ b/tests/baselines/reference/declaredClassMergedwithSelf.js @@ -1,8 +1,6 @@ //// [tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts] //// //// [file1.ts] - - declare class C1 {} declare class C1 {} @@ -14,11 +12,9 @@ interface C2 {} declare class C2 {} //// [file2.ts] - declare class C3 { } //// [file3.ts] - declare class C3 { } //// [file1.js] diff --git a/tests/baselines/reference/decoratedClassExportsCommonJS2.js b/tests/baselines/reference/decoratedClassExportsCommonJS2.js index 978d8f18402..b9ef278ac73 100644 --- a/tests/baselines/reference/decoratedClassExportsCommonJS2.js +++ b/tests/baselines/reference/decoratedClassExportsCommonJS2.js @@ -1,5 +1,4 @@ //// [a.ts] - declare function forwardRef(x: any): any; declare var Something: any; @Something({ v: () => Testing123 }) diff --git a/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols b/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols index 8f587c1bff1..77b1f920792 100644 --- a/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols +++ b/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : Symbol(forwardRef, Decl(a.ts, 0, 0)) ->x : Symbol(x, Decl(a.ts, 1, 28)) +>x : Symbol(x, Decl(a.ts, 0, 28)) declare var Something: any; ->Something : Symbol(Something, Decl(a.ts, 2, 11)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) @Something({ v: () => Testing123 }) ->Something : Symbol(Something, Decl(a.ts, 2, 11)) ->v : Symbol(v, Decl(a.ts, 3, 12)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) +>v : Symbol(v, Decl(a.ts, 2, 12)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) export class Testing123 { } ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) diff --git a/tests/baselines/reference/decoratedClassExportsCommonJS2.types b/tests/baselines/reference/decoratedClassExportsCommonJS2.types index eba793247de..4c8cdfe4287 100644 --- a/tests/baselines/reference/decoratedClassExportsCommonJS2.types +++ b/tests/baselines/reference/decoratedClassExportsCommonJS2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : (x: any) => any >x : any diff --git a/tests/baselines/reference/decoratedClassExportsSystem1.js b/tests/baselines/reference/decoratedClassExportsSystem1.js index 2f33feb28fb..b32c2c9b445 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem1.js +++ b/tests/baselines/reference/decoratedClassExportsSystem1.js @@ -1,5 +1,4 @@ //// [a.ts] - declare function forwardRef(x: any): any; declare var Something: any; @Something({ v: () => Testing123 }) diff --git a/tests/baselines/reference/decoratedClassExportsSystem1.symbols b/tests/baselines/reference/decoratedClassExportsSystem1.symbols index 559f78624e3..f81efa4d475 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem1.symbols +++ b/tests/baselines/reference/decoratedClassExportsSystem1.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : Symbol(forwardRef, Decl(a.ts, 0, 0)) ->x : Symbol(x, Decl(a.ts, 1, 28)) +>x : Symbol(x, Decl(a.ts, 0, 28)) declare var Something: any; ->Something : Symbol(Something, Decl(a.ts, 2, 11)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) @Something({ v: () => Testing123 }) ->Something : Symbol(Something, Decl(a.ts, 2, 11)) ->v : Symbol(v, Decl(a.ts, 3, 12)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) +>v : Symbol(v, Decl(a.ts, 2, 12)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) export class Testing123 { ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) static prop0: string; ->prop0 : Symbol(Testing123.prop0, Decl(a.ts, 4, 25)) +>prop0 : Symbol(Testing123.prop0, Decl(a.ts, 3, 25)) static prop1 = Testing123.prop0; ->prop1 : Symbol(Testing123.prop1, Decl(a.ts, 5, 25)) ->Testing123.prop0 : Symbol(Testing123.prop0, Decl(a.ts, 4, 25)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) ->prop0 : Symbol(Testing123.prop0, Decl(a.ts, 4, 25)) +>prop1 : Symbol(Testing123.prop1, Decl(a.ts, 4, 25)) +>Testing123.prop0 : Symbol(Testing123.prop0, Decl(a.ts, 3, 25)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) +>prop0 : Symbol(Testing123.prop0, Decl(a.ts, 3, 25)) } diff --git a/tests/baselines/reference/decoratedClassExportsSystem1.types b/tests/baselines/reference/decoratedClassExportsSystem1.types index 1cc69e8b680..6b6a248d1dd 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem1.types +++ b/tests/baselines/reference/decoratedClassExportsSystem1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : (x: any) => any >x : any diff --git a/tests/baselines/reference/decoratedClassExportsSystem2.js b/tests/baselines/reference/decoratedClassExportsSystem2.js index 2c9c62cadb2..99ddd29bc2c 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem2.js +++ b/tests/baselines/reference/decoratedClassExportsSystem2.js @@ -1,5 +1,4 @@ //// [a.ts] - declare function forwardRef(x: any): any; declare var Something: any; @Something({ v: () => Testing123 }) diff --git a/tests/baselines/reference/decoratedClassExportsSystem2.symbols b/tests/baselines/reference/decoratedClassExportsSystem2.symbols index 8f587c1bff1..77b1f920792 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem2.symbols +++ b/tests/baselines/reference/decoratedClassExportsSystem2.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : Symbol(forwardRef, Decl(a.ts, 0, 0)) ->x : Symbol(x, Decl(a.ts, 1, 28)) +>x : Symbol(x, Decl(a.ts, 0, 28)) declare var Something: any; ->Something : Symbol(Something, Decl(a.ts, 2, 11)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) @Something({ v: () => Testing123 }) ->Something : Symbol(Something, Decl(a.ts, 2, 11)) ->v : Symbol(v, Decl(a.ts, 3, 12)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) +>v : Symbol(v, Decl(a.ts, 2, 12)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) export class Testing123 { } ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) diff --git a/tests/baselines/reference/decoratedClassExportsSystem2.types b/tests/baselines/reference/decoratedClassExportsSystem2.types index eba793247de..4c8cdfe4287 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem2.types +++ b/tests/baselines/reference/decoratedClassExportsSystem2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : (x: any) => any >x : any diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt b/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt index cef2f90f704..f9dd5b63b57 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts(9,14): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. +tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts(8,14): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. ==== tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts (1 errors) ==== - // from #2971 function func(s: string): void { } diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.js b/tests/baselines/reference/decoratorChecksFunctionBodies.js index 68dbe6bd1ef..20a58980e44 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.js +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.js @@ -1,5 +1,4 @@ //// [decoratorChecksFunctionBodies.ts] - // from #2971 function func(s: string): void { } diff --git a/tests/baselines/reference/decoratorInJsFile.errors.txt b/tests/baselines/reference/decoratorInJsFile.errors.txt index 93bd5143b74..521c67d4e23 100644 --- a/tests/baselines/reference/decoratorInJsFile.errors.txt +++ b/tests/baselines/reference/decoratorInJsFile.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.js(4,12): error TS8010: 'types' can only be used in a .ts file. +tests/cases/compiler/a.js(3,12): error TS8010: 'types' can only be used in a .ts file. ==== tests/cases/compiler/a.js (1 errors) ==== - @SomeDecorator class SomeClass { foo(x: number) { diff --git a/tests/baselines/reference/decoratorInJsFile1.errors.txt b/tests/baselines/reference/decoratorInJsFile1.errors.txt index f4422c0c2d9..d660b6b28df 100644 --- a/tests/baselines/reference/decoratorInJsFile1.errors.txt +++ b/tests/baselines/reference/decoratorInJsFile1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.js(3,7): error TS1219: Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option to remove this warning. -tests/cases/compiler/a.js(4,12): error TS8010: 'types' can only be used in a .ts file. +tests/cases/compiler/a.js(2,7): error TS1219: Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option to remove this warning. +tests/cases/compiler/a.js(3,12): error TS8010: 'types' can only be used in a .ts file. ==== tests/cases/compiler/a.js (2 errors) ==== - @SomeDecorator class SomeClass { ~~~~~~~~~ diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js index 22e4a448f1e..08184bb7e6c 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/class/decoratorInstantiateModulesInFunctionBodies.ts] //// //// [a.ts] - // from #3108 export var test = 'abc'; diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols index f7c96097caf..15993fc6b5a 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/decorators/class/a.ts === - // from #3108 export var test = 'abc'; ->test : Symbol(test, Decl(a.ts, 2, 10)) +>test : Symbol(test, Decl(a.ts, 1, 10)) === tests/cases/conformance/decorators/class/b.ts === import { test } from './a'; diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types index d768f3c6c7a..d93f3d119d2 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - // from #3108 export var test = 'abc'; >test : string diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js index 970447efae0..9647165b650 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js @@ -1,5 +1,4 @@ //// [decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts] - declare var decorator: any; class MyClass { diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols index cf550fb26e1..ed09206356e 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts === - declare var decorator: any; ->decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 0, 11)) class MyClass { ->MyClass : Symbol(MyClass, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 1, 27)) +>MyClass : Symbol(MyClass, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 0, 27)) constructor(test: string, test2: number) { ->test : Symbol(test, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 4, 16)) ->test2 : Symbol(test2, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 4, 29)) +>test : Symbol(test, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 3, 16)) +>test2 : Symbol(test2, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 3, 29)) } @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 0, 11)) doSomething() { ->doSomething : Symbol(MyClass.doSomething, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 6, 5)) +>doSomething : Symbol(MyClass.doSomething, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 5, 5)) } } diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types index aebd8143eab..2b372eebdf2 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts === - declare var decorator: any; >decorator : any diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.js b/tests/baselines/reference/decoratorMetadataOnInferredType.js index 6f247637729..e7bd55ada6f 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.js +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.js @@ -1,5 +1,4 @@ //// [decoratorMetadataOnInferredType.ts] - declare var console: { log(msg: string): void; }; diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols index 5e0568a44a2..3230c270f2b 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/decoratorMetadataOnInferredType.ts === - declare var console: { ->console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 1, 11)) +>console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 0, 11)) log(msg: string): void; ->log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 1, 22)) ->msg : Symbol(msg, Decl(decoratorMetadataOnInferredType.ts, 2, 8)) +>log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 0, 22)) +>msg : Symbol(msg, Decl(decoratorMetadataOnInferredType.ts, 1, 8)) }; class A { ->A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 3, 2)) +>A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 2, 2)) constructor() { console.log('new A'); } ->console.log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 1, 22)) ->console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 1, 22)) +>console.log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 0, 22)) +>console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 0, 22)) } function decorator(target: Object, propertyKey: string) { ->decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 7, 1)) ->target : Symbol(target, Decl(decoratorMetadataOnInferredType.ts, 9, 19)) +>decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 6, 1)) +>target : Symbol(target, Decl(decoratorMetadataOnInferredType.ts, 8, 19)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->propertyKey : Symbol(propertyKey, Decl(decoratorMetadataOnInferredType.ts, 9, 34)) +>propertyKey : Symbol(propertyKey, Decl(decoratorMetadataOnInferredType.ts, 8, 34)) } export class B { ->B : Symbol(B, Decl(decoratorMetadataOnInferredType.ts, 10, 1)) +>B : Symbol(B, Decl(decoratorMetadataOnInferredType.ts, 9, 1)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 7, 1)) +>decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 6, 1)) x = new A(); ->x : Symbol(B.x, Decl(decoratorMetadataOnInferredType.ts, 12, 16)) ->A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 3, 2)) +>x : Symbol(B.x, Decl(decoratorMetadataOnInferredType.ts, 11, 16)) +>A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 2, 2)) } diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.types b/tests/baselines/reference/decoratorMetadataOnInferredType.types index 41ac7f060d2..a3ef51dfe26 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.types +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataOnInferredType.ts === - declare var console: { >console : { log(msg: string): void; } diff --git a/tests/baselines/reference/decoratorMetadataPromise.js b/tests/baselines/reference/decoratorMetadataPromise.js index 23491449dfa..a370df936d5 100644 --- a/tests/baselines/reference/decoratorMetadataPromise.js +++ b/tests/baselines/reference/decoratorMetadataPromise.js @@ -1,5 +1,4 @@ //// [decoratorMetadataPromise.ts] - declare const decorator: MethodDecorator; class A { diff --git a/tests/baselines/reference/decoratorMetadataPromise.symbols b/tests/baselines/reference/decoratorMetadataPromise.symbols index 6eec0fe4623..ae929a4e342 100644 --- a/tests/baselines/reference/decoratorMetadataPromise.symbols +++ b/tests/baselines/reference/decoratorMetadataPromise.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/decoratorMetadataPromise.ts === - declare const decorator: MethodDecorator; ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) >MethodDecorator : Symbol(MethodDecorator, Decl(lib.es5.d.ts, --, --)) class A { ->A : Symbol(A, Decl(decoratorMetadataPromise.ts, 1, 41)) +>A : Symbol(A, Decl(decoratorMetadataPromise.ts, 0, 41)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) async foo() {} ->foo : Symbol(A.foo, Decl(decoratorMetadataPromise.ts, 3, 9)) +>foo : Symbol(A.foo, Decl(decoratorMetadataPromise.ts, 2, 9)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) async bar(): Promise { return 0; } ->bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 5, 18)) +>bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 4, 18)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) baz(n: Promise): Promise { return n; } ->baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 7, 46)) ->n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8)) +>baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 6, 46)) +>n : Symbol(n, Decl(decoratorMetadataPromise.ts, 8, 8)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) ->n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8)) +>n : Symbol(n, Decl(decoratorMetadataPromise.ts, 8, 8)) } diff --git a/tests/baselines/reference/decoratorMetadataPromise.types b/tests/baselines/reference/decoratorMetadataPromise.types index eff5fe92c12..1740f78c601 100644 --- a/tests/baselines/reference/decoratorMetadataPromise.types +++ b/tests/baselines/reference/decoratorMetadataPromise.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataPromise.ts === - declare const decorator: MethodDecorator; >decorator : MethodDecorator >MethodDecorator : MethodDecorator diff --git a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js index a65ba5b2f73..404bc9a1d59 100644 --- a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js +++ b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/decoratorMetadataRestParameterWithImportedType.ts] //// //// [aux.ts] - export class SomeClass { field: string; } diff --git a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols index 9bd293cdfcb..8b8fdf243f8 100644 --- a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols +++ b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/aux.ts === - export class SomeClass { >SomeClass : Symbol(SomeClass, Decl(aux.ts, 0, 0)) field: string; ->field : Symbol(SomeClass.field, Decl(aux.ts, 1, 24)) +>field : Symbol(SomeClass.field, Decl(aux.ts, 0, 24)) } === tests/cases/compiler/aux1.ts === diff --git a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types index 6c27aa2c942..60db876576d 100644 --- a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types +++ b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/aux.ts === - export class SomeClass { >SomeClass : SomeClass diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.js b/tests/baselines/reference/decoratorMetadataWithConstructorType.js index 10aa42ddce7..95c19178345 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.js +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.js @@ -1,5 +1,4 @@ //// [decoratorMetadataWithConstructorType.ts] - declare var console: { log(msg: string): void; }; diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols index 5ee6edd1aee..cfe4fc002d6 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/decoratorMetadataWithConstructorType.ts === - declare var console: { ->console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 1, 11)) +>console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 0, 11)) log(msg: string): void; ->log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 1, 22)) ->msg : Symbol(msg, Decl(decoratorMetadataWithConstructorType.ts, 2, 8)) +>log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 0, 22)) +>msg : Symbol(msg, Decl(decoratorMetadataWithConstructorType.ts, 1, 8)) }; class A { ->A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 3, 2)) +>A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 2, 2)) constructor() { console.log('new A'); } ->console.log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 1, 22)) ->console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 1, 22)) +>console.log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 0, 22)) +>console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 0, 22)) } function decorator(target: Object, propertyKey: string) { ->decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 7, 1)) ->target : Symbol(target, Decl(decoratorMetadataWithConstructorType.ts, 9, 19)) +>decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 6, 1)) +>target : Symbol(target, Decl(decoratorMetadataWithConstructorType.ts, 8, 19)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->propertyKey : Symbol(propertyKey, Decl(decoratorMetadataWithConstructorType.ts, 9, 34)) +>propertyKey : Symbol(propertyKey, Decl(decoratorMetadataWithConstructorType.ts, 8, 34)) } export class B { ->B : Symbol(B, Decl(decoratorMetadataWithConstructorType.ts, 10, 1)) +>B : Symbol(B, Decl(decoratorMetadataWithConstructorType.ts, 9, 1)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 7, 1)) +>decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 6, 1)) x: A = new A(); ->x : Symbol(B.x, Decl(decoratorMetadataWithConstructorType.ts, 12, 16)) ->A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 3, 2)) ->A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 3, 2)) +>x : Symbol(B.x, Decl(decoratorMetadataWithConstructorType.ts, 11, 16)) +>A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 2, 2)) +>A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 2, 2)) } diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.types b/tests/baselines/reference/decoratorMetadataWithConstructorType.types index 4ca404c8116..262e31c3845 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.types +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataWithConstructorType.ts === - declare var console: { >console : { log(msg: string): void; } diff --git a/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt b/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt index c4585b8301f..603c449aeb4 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt +++ b/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt @@ -3,7 +3,6 @@ tests/cases/conformance/decorators/class/constructor/2.ts(2,19): error TS2691: A ==== tests/cases/conformance/decorators/class/constructor/0.ts (0 errors) ==== - export class base { } export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } diff --git a/tests/baselines/reference/decoratorOnClassConstructor2.js b/tests/baselines/reference/decoratorOnClassConstructor2.js index 2af3b0426dc..999ffbc5e60 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor2.js +++ b/tests/baselines/reference/decoratorOnClassConstructor2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/class/constructor/decoratorOnClassConstructor2.ts] //// //// [0.ts] - export class base { } export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } diff --git a/tests/baselines/reference/decoratorOnClassConstructor3.js b/tests/baselines/reference/decoratorOnClassConstructor3.js index 4ed401284a9..98edaebe920 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor3.js +++ b/tests/baselines/reference/decoratorOnClassConstructor3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/class/constructor/decoratorOnClassConstructor3.ts] //// //// [0.ts] - export class base { } export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } diff --git a/tests/baselines/reference/decoratorOnClassConstructor3.symbols b/tests/baselines/reference/decoratorOnClassConstructor3.symbols index 12c20c9a8cc..3db6bf0f936 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor3.symbols +++ b/tests/baselines/reference/decoratorOnClassConstructor3.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/decorators/class/constructor/0.ts === - export class base { } >base : Symbol(base, Decl(0.ts, 0, 0)) export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } ->foo : Symbol(foo, Decl(0.ts, 1, 21)) ->target : Symbol(target, Decl(0.ts, 2, 20)) +>foo : Symbol(foo, Decl(0.ts, 0, 21)) +>target : Symbol(target, Decl(0.ts, 1, 20)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->propertyKey : Symbol(propertyKey, Decl(0.ts, 2, 35)) ->parameterIndex : Symbol(parameterIndex, Decl(0.ts, 2, 65)) +>propertyKey : Symbol(propertyKey, Decl(0.ts, 1, 35)) +>parameterIndex : Symbol(parameterIndex, Decl(0.ts, 1, 65)) === tests/cases/conformance/decorators/class/constructor/2.ts === import {base} from "./0" diff --git a/tests/baselines/reference/decoratorOnClassConstructor3.types b/tests/baselines/reference/decoratorOnClassConstructor3.types index dc1e22c1688..49e16d09e76 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor3.types +++ b/tests/baselines/reference/decoratorOnClassConstructor3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/constructor/0.ts === - export class base { } >base : base diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.js b/tests/baselines/reference/decoratorWithUnderscoreMethod.js index bf79890263b..9ac2a88aa51 100644 --- a/tests/baselines/reference/decoratorWithUnderscoreMethod.js +++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.js @@ -1,5 +1,4 @@ //// [decoratorWithUnderscoreMethod.ts] - declare var console : { log(arg: string): void }; function dec(): Function { return function (target: any, propKey: string, descr: PropertyDescriptor): void { diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols b/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols index a512bde71f6..b9c7be21514 100644 --- a/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols +++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/decoratorWithUnderscoreMethod.ts === - declare var console : { log(arg: string): void }; ->console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 1, 23)) ->arg : Symbol(arg, Decl(decoratorWithUnderscoreMethod.ts, 1, 28)) +>console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23)) +>arg : Symbol(arg, Decl(decoratorWithUnderscoreMethod.ts, 0, 28)) function dec(): Function { ->dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 1, 49)) +>dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 0, 49)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return function (target: any, propKey: string, descr: PropertyDescriptor): void { ->target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 3, 21)) ->propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 3, 33)) ->descr : Symbol(descr, Decl(decoratorWithUnderscoreMethod.ts, 3, 50)) +>target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 2, 21)) +>propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 2, 33)) +>descr : Symbol(descr, Decl(decoratorWithUnderscoreMethod.ts, 2, 50)) >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --)) console.log(target[propKey]); ->console.log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 1, 23)) ->console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 1, 23)) ->target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 3, 21)) ->propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 3, 33)) +>console.log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23)) +>console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23)) +>target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 2, 21)) +>propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 2, 33)) //logs undefined //propKey has three underscores as prefix, but the method has only two underscores @@ -28,14 +27,14 @@ function dec(): Function { } class A { ->A : Symbol(A, Decl(decoratorWithUnderscoreMethod.ts, 8, 1)) +>A : Symbol(A, Decl(decoratorWithUnderscoreMethod.ts, 7, 1)) @dec() ->dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 1, 49)) +>dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 0, 49)) private __foo(bar: string): void { ->__foo : Symbol(A.__foo, Decl(decoratorWithUnderscoreMethod.ts, 10, 9)) ->bar : Symbol(bar, Decl(decoratorWithUnderscoreMethod.ts, 12, 18)) +>__foo : Symbol(A.__foo, Decl(decoratorWithUnderscoreMethod.ts, 9, 9)) +>bar : Symbol(bar, Decl(decoratorWithUnderscoreMethod.ts, 11, 18)) // do something with bar } diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.types b/tests/baselines/reference/decoratorWithUnderscoreMethod.types index 1ce08dc8a9e..a75952d37aa 100644 --- a/tests/baselines/reference/decoratorWithUnderscoreMethod.types +++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorWithUnderscoreMethod.ts === - declare var console : { log(arg: string): void }; >console : { log(arg: string): void; } >log : (arg: string) => void diff --git a/tests/baselines/reference/defaultExportWithOverloads01.js b/tests/baselines/reference/defaultExportWithOverloads01.js index a273b891679..1b403038750 100644 --- a/tests/baselines/reference/defaultExportWithOverloads01.js +++ b/tests/baselines/reference/defaultExportWithOverloads01.js @@ -1,5 +1,4 @@ //// [defaultExportWithOverloads01.ts] - export default function f(); export default function f(x: string); export default function f(...args: any[]) { diff --git a/tests/baselines/reference/defaultExportWithOverloads01.symbols b/tests/baselines/reference/defaultExportWithOverloads01.symbols index a5ff0df5262..2438f8d838b 100644 --- a/tests/baselines/reference/defaultExportWithOverloads01.symbols +++ b/tests/baselines/reference/defaultExportWithOverloads01.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts === - export default function f(); ->f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37)) +>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 0, 28), Decl(defaultExportWithOverloads01.ts, 1, 37)) export default function f(x: string); ->f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37)) ->x : Symbol(x, Decl(defaultExportWithOverloads01.ts, 2, 26)) +>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 0, 28), Decl(defaultExportWithOverloads01.ts, 1, 37)) +>x : Symbol(x, Decl(defaultExportWithOverloads01.ts, 1, 26)) export default function f(...args: any[]) { ->f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37)) ->args : Symbol(args, Decl(defaultExportWithOverloads01.ts, 3, 26)) +>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 0, 28), Decl(defaultExportWithOverloads01.ts, 1, 37)) +>args : Symbol(args, Decl(defaultExportWithOverloads01.ts, 2, 26)) } diff --git a/tests/baselines/reference/defaultExportWithOverloads01.types b/tests/baselines/reference/defaultExportWithOverloads01.types index c006083b4ba..6b8883783f3 100644 --- a/tests/baselines/reference/defaultExportWithOverloads01.types +++ b/tests/baselines/reference/defaultExportWithOverloads01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts === - export default function f(); >f : { (): any; (x: string): any; } diff --git a/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt index 15c60e32d9f..5c28d8ee141 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. -tests/cases/conformance/es6/modules/m1.ts(11,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(1,25): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(10,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'. ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ==== - export default function Decl() { ~~~~ !!! error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge01.js b/tests/baselines/reference/defaultExportsCannotMerge01.js index aaadfaefebb..c7091371d36 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge01.js +++ b/tests/baselines/reference/defaultExportsCannotMerge01.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/defaultExportsCannotMerge01.ts] //// //// [m1.ts] - export default function Decl() { return 0; } diff --git a/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt index 30bab504c7e..737a481487b 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. -tests/cases/conformance/es6/modules/m1.ts(5,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(1,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(4,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'. ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ==== - export default class Decl { ~~~~ !!! error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge02.js b/tests/baselines/reference/defaultExportsCannotMerge02.js index b83d54548ca..19a2de45077 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge02.js +++ b/tests/baselines/reference/defaultExportsCannotMerge02.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/defaultExportsCannotMerge02.ts] //// //// [m1.ts] - export default class Decl { } diff --git a/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt index e8782abedd6..7452554fd35 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. -tests/cases/conformance/es6/modules/m1.ts(5,11): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(1,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(4,11): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'. ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ==== - export default class Decl { ~~~~ !!! error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge03.js b/tests/baselines/reference/defaultExportsCannotMerge03.js index 254723ec5f1..1f8ac49f3c4 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge03.js +++ b/tests/baselines/reference/defaultExportsCannotMerge03.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/defaultExportsCannotMerge03.ts] //// //// [m1.ts] - export default class Decl { } diff --git a/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt index 000a9b8f30e..91e07720c89 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(2,25): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(5,11): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(9,11): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(12,18): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(1,25): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(4,11): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(8,11): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(11,18): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. ==== tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts (4 errors) ==== - export default function Foo() { ~~~ !!! error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge04.js b/tests/baselines/reference/defaultExportsCannotMerge04.js index 38ab4861c62..de32618d8cc 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge04.js +++ b/tests/baselines/reference/defaultExportsCannotMerge04.js @@ -1,5 +1,4 @@ //// [defaultExportsCannotMerge04.ts] - export default function Foo() { } diff --git a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js index 7706181b343..35e8ec98a8e 100644 --- a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js +++ b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js @@ -1,5 +1,4 @@ //// [defaultOfAnyInStrictNullChecks.ts] - // Regression test for #8295 function foo() { diff --git a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols index c7de7f6b2f3..d500d7c8bf6 100644 --- a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols +++ b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/defaultOfAnyInStrictNullChecks.ts === - // Regression test for #8295 function foo() { @@ -8,11 +7,11 @@ function foo() { try { } catch (e) { ->e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 6, 11)) +>e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 5, 11)) let s = e.message; ->s : Symbol(s, Decl(defaultOfAnyInStrictNullChecks.ts, 7, 11)) ->e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 6, 11)) +>s : Symbol(s, Decl(defaultOfAnyInStrictNullChecks.ts, 6, 11)) +>e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 5, 11)) } } diff --git a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types index 8e4c1adcd61..bae0ac690f2 100644 --- a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types +++ b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types @@ -1,5 +1,4 @@ === tests/cases/compiler/defaultOfAnyInStrictNullChecks.ts === - // Regression test for #8295 function foo() { diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js index a1e9399c563..d41542e90c0 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js @@ -1,5 +1,4 @@ //// [derivedClassConstructorWithExplicitReturns01.ts] - class C { cProp = 10; diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map index f2acf9427cf..4075fca49c9 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map @@ -1,2 +1,2 @@ //// [derivedClassConstructorWithExplicitReturns01.js.map] -{"version":3,"file":"derivedClassConstructorWithExplicitReturns01.js","sourceRoot":"","sources":["derivedClassConstructorWithExplicitReturns01.ts"],"names":[],"mappings":";;;;;;;;;;AACA;IAKI,WAAY,KAAa;QAJzB,UAAK,GAAG,EAAE,CAAC;QAKP,MAAM,CAAC;YACH,KAAK,EAAE,KAAK;YACZ,GAAG;gBACC,MAAM,CAAC,8BAA8B,CAAC;YAC1C,CAAC;SACJ,CAAA;IACL,CAAC;IATD,eAAG,GAAH,cAAQ,MAAM,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAU7C,QAAC;AAAD,CAAC,AAbD,IAaC;AAED;IAAgB,qBAAC;IAGb,WAAY,CAAO;QAAP,kBAAA,EAAA,OAAO;QAAnB,YACI,kBAAM,CAAC,CAAC,SAYX;QAfD,WAAK,GAAG,cAAM,OAAA,KAAI,EAAJ,CAAI,CAAC;QAKf,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACtB,UAAU,CAAA;YACV,MAAM,CAAC;gBACH,KAAK,EAAE,CAAC;gBACR,KAAK,EAAE,cAAM,OAAA,KAAI,EAAJ,CAAI;gBACjB,GAAG,gBAAK,MAAM,CAAC,cAAc,CAAA,CAAC,CAAC;aAClC,CAAC;QACN,CAAC;QACD,IAAI;YACA,MAAM,CAAC,IAAI,CAAC;IACpB,CAAC;IACL,QAAC;AAAD,CAAC,AAjBD,CAAgB,CAAC,GAiBhB"} \ No newline at end of file +{"version":3,"file":"derivedClassConstructorWithExplicitReturns01.js","sourceRoot":"","sources":["derivedClassConstructorWithExplicitReturns01.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;IAKI,WAAY,KAAa;QAJzB,UAAK,GAAG,EAAE,CAAC;QAKP,MAAM,CAAC;YACH,KAAK,EAAE,KAAK;YACZ,GAAG;gBACC,MAAM,CAAC,8BAA8B,CAAC;YAC1C,CAAC;SACJ,CAAA;IACL,CAAC;IATD,eAAG,GAAH,cAAQ,MAAM,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAU7C,QAAC;AAAD,CAAC,AAbD,IAaC;AAED;IAAgB,qBAAC;IAGb,WAAY,CAAO;QAAP,kBAAA,EAAA,OAAO;QAAnB,YACI,kBAAM,CAAC,CAAC,SAYX;QAfD,WAAK,GAAG,cAAM,OAAA,KAAI,EAAJ,CAAI,CAAC;QAKf,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACtB,UAAU,CAAA;YACV,MAAM,CAAC;gBACH,KAAK,EAAE,CAAC;gBACR,KAAK,EAAE,cAAM,OAAA,KAAI,EAAJ,CAAI;gBACjB,GAAG,gBAAK,MAAM,CAAC,cAAc,CAAA,CAAC,CAAC;aAClC,CAAC;QACN,CAAC;QACD,IAAI;YACA,MAAM,CAAC,IAAI,CAAC;IACpB,CAAC;IACL,QAAC;AAAD,CAAC,AAjBD,CAAgB,CAAC,GAiBhB"} \ No newline at end of file diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt index 42d415430e2..76da9ac8a5a 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt @@ -21,9 +21,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts >>>var C = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(11, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(11, 1) Source(1, 1) + SourceIndex(0) --- >>> function C(value) { 1->^^^^ @@ -38,9 +37,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > constructor( 3 > value: number -1->Emitted(12, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(12, 16) Source(7, 17) + SourceIndex(0) -3 >Emitted(12, 21) Source(7, 30) + SourceIndex(0) +1->Emitted(12, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(12, 16) Source(6, 17) + SourceIndex(0) +3 >Emitted(12, 21) Source(6, 30) + SourceIndex(0) --- >>> this.cProp = 10; 1->^^^^^^^^ @@ -53,11 +52,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 3 > = 4 > 10 5 > ; -1->Emitted(13, 9) Source(3, 5) + SourceIndex(0) -2 >Emitted(13, 19) Source(3, 10) + SourceIndex(0) -3 >Emitted(13, 22) Source(3, 13) + SourceIndex(0) -4 >Emitted(13, 24) Source(3, 15) + SourceIndex(0) -5 >Emitted(13, 25) Source(3, 16) + SourceIndex(0) +1->Emitted(13, 9) Source(2, 5) + SourceIndex(0) +2 >Emitted(13, 19) Source(2, 10) + SourceIndex(0) +3 >Emitted(13, 22) Source(2, 13) + SourceIndex(0) +4 >Emitted(13, 24) Source(2, 15) + SourceIndex(0) +5 >Emitted(13, 25) Source(2, 16) + SourceIndex(0) --- >>> return { 1 >^^^^^^^^ @@ -72,9 +71,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > return 3 > -1 >Emitted(14, 9) Source(8, 9) + SourceIndex(0) -2 >Emitted(14, 15) Source(8, 15) + SourceIndex(0) -3 >Emitted(14, 16) Source(8, 16) + SourceIndex(0) +1 >Emitted(14, 9) Source(7, 9) + SourceIndex(0) +2 >Emitted(14, 15) Source(7, 15) + SourceIndex(0) +3 >Emitted(14, 16) Source(7, 16) + SourceIndex(0) --- >>> cProp: value, 1->^^^^^^^^^^^^ @@ -87,10 +86,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 2 > cProp 3 > : 4 > value -1->Emitted(15, 13) Source(9, 13) + SourceIndex(0) -2 >Emitted(15, 18) Source(9, 18) + SourceIndex(0) -3 >Emitted(15, 20) Source(9, 20) + SourceIndex(0) -4 >Emitted(15, 25) Source(9, 25) + SourceIndex(0) +1->Emitted(15, 13) Source(8, 13) + SourceIndex(0) +2 >Emitted(15, 18) Source(8, 18) + SourceIndex(0) +3 >Emitted(15, 20) Source(8, 20) + SourceIndex(0) +4 >Emitted(15, 25) Source(8, 25) + SourceIndex(0) --- >>> foo: function () { 1->^^^^^^^^^^^^ @@ -99,8 +98,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1->, > 2 > foo -1->Emitted(16, 13) Source(10, 13) + SourceIndex(0) -2 >Emitted(16, 16) Source(10, 16) + SourceIndex(0) +1->Emitted(16, 13) Source(9, 13) + SourceIndex(0) +2 >Emitted(16, 16) Source(9, 16) + SourceIndex(0) --- >>> return "well this looks kinda C-ish."; 1->^^^^^^^^^^^^^^^^ @@ -114,11 +113,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 3 > 4 > "well this looks kinda C-ish." 5 > ; -1->Emitted(17, 17) Source(11, 17) + SourceIndex(0) -2 >Emitted(17, 23) Source(11, 23) + SourceIndex(0) -3 >Emitted(17, 24) Source(11, 24) + SourceIndex(0) -4 >Emitted(17, 54) Source(11, 54) + SourceIndex(0) -5 >Emitted(17, 55) Source(11, 55) + SourceIndex(0) +1->Emitted(17, 17) Source(10, 17) + SourceIndex(0) +2 >Emitted(17, 23) Source(10, 23) + SourceIndex(0) +3 >Emitted(17, 24) Source(10, 24) + SourceIndex(0) +4 >Emitted(17, 54) Source(10, 54) + SourceIndex(0) +5 >Emitted(17, 55) Source(10, 55) + SourceIndex(0) --- >>> } 1 >^^^^^^^^^^^^ @@ -126,8 +125,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(18, 13) Source(12, 13) + SourceIndex(0) -2 >Emitted(18, 14) Source(12, 14) + SourceIndex(0) +1 >Emitted(18, 13) Source(11, 13) + SourceIndex(0) +2 >Emitted(18, 14) Source(11, 14) + SourceIndex(0) --- >>> }; 1 >^^^^^^^^^ @@ -135,8 +134,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > } 2 > -1 >Emitted(19, 10) Source(13, 10) + SourceIndex(0) -2 >Emitted(19, 11) Source(13, 10) + SourceIndex(0) +1 >Emitted(19, 10) Source(12, 10) + SourceIndex(0) +2 >Emitted(19, 11) Source(12, 10) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -145,8 +144,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(20, 5) Source(14, 5) + SourceIndex(0) -2 >Emitted(20, 6) Source(14, 6) + SourceIndex(0) +1 >Emitted(20, 5) Source(13, 5) + SourceIndex(0) +2 >Emitted(20, 6) Source(13, 6) + SourceIndex(0) --- >>> C.prototype.foo = function () { return "this never gets used."; }; 1->^^^^ @@ -169,16 +168,16 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 8 > ; 9 > 10> } -1->Emitted(21, 5) Source(5, 5) + SourceIndex(0) -2 >Emitted(21, 20) Source(5, 8) + SourceIndex(0) -3 >Emitted(21, 23) Source(5, 5) + SourceIndex(0) -4 >Emitted(21, 37) Source(5, 13) + SourceIndex(0) -5 >Emitted(21, 43) Source(5, 19) + SourceIndex(0) -6 >Emitted(21, 44) Source(5, 20) + SourceIndex(0) -7 >Emitted(21, 67) Source(5, 43) + SourceIndex(0) -8 >Emitted(21, 68) Source(5, 44) + SourceIndex(0) -9 >Emitted(21, 69) Source(5, 45) + SourceIndex(0) -10>Emitted(21, 70) Source(5, 46) + SourceIndex(0) +1->Emitted(21, 5) Source(4, 5) + SourceIndex(0) +2 >Emitted(21, 20) Source(4, 8) + SourceIndex(0) +3 >Emitted(21, 23) Source(4, 5) + SourceIndex(0) +4 >Emitted(21, 37) Source(4, 13) + SourceIndex(0) +5 >Emitted(21, 43) Source(4, 19) + SourceIndex(0) +6 >Emitted(21, 44) Source(4, 20) + SourceIndex(0) +7 >Emitted(21, 67) Source(4, 43) + SourceIndex(0) +8 >Emitted(21, 68) Source(4, 44) + SourceIndex(0) +9 >Emitted(21, 69) Source(4, 45) + SourceIndex(0) +10>Emitted(21, 70) Source(4, 46) + SourceIndex(0) --- >>> return C; 1 >^^^^ @@ -195,8 +194,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > } > 2 > } -1 >Emitted(22, 5) Source(15, 1) + SourceIndex(0) -2 >Emitted(22, 13) Source(15, 2) + SourceIndex(0) +1 >Emitted(22, 5) Source(14, 1) + SourceIndex(0) +2 >Emitted(22, 13) Source(14, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -221,10 +220,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > } > } > } -1 >Emitted(23, 1) Source(15, 1) + SourceIndex(0) -2 >Emitted(23, 2) Source(15, 2) + SourceIndex(0) -3 >Emitted(23, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(23, 6) Source(15, 2) + SourceIndex(0) +1 >Emitted(23, 1) Source(14, 1) + SourceIndex(0) +2 >Emitted(23, 2) Source(14, 2) + SourceIndex(0) +3 >Emitted(23, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(23, 6) Source(14, 2) + SourceIndex(0) --- >>>var D = (function (_super) { 1-> @@ -232,15 +231,15 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1-> > > -1->Emitted(24, 1) Source(17, 1) + SourceIndex(0) +1->Emitted(24, 1) Source(16, 1) + SourceIndex(0) --- >>> __extends(D, _super); 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^ 1->class D extends 2 > C -1->Emitted(25, 5) Source(17, 17) + SourceIndex(0) -2 >Emitted(25, 26) Source(17, 18) + SourceIndex(0) +1->Emitted(25, 5) Source(16, 17) + SourceIndex(0) +2 >Emitted(25, 26) Source(16, 18) + SourceIndex(0) --- >>> function D(a) { 1 >^^^^ @@ -253,9 +252,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > constructor( 3 > a = 100 -1 >Emitted(26, 5) Source(20, 5) + SourceIndex(0) -2 >Emitted(26, 16) Source(20, 17) + SourceIndex(0) -3 >Emitted(26, 17) Source(20, 24) + SourceIndex(0) +1 >Emitted(26, 5) Source(19, 5) + SourceIndex(0) +2 >Emitted(26, 16) Source(19, 17) + SourceIndex(0) +3 >Emitted(26, 17) Source(19, 24) + SourceIndex(0) --- >>> if (a === void 0) { a = 100; } 1->^^^^^^^^ @@ -267,10 +266,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 2 > 3 > 4 > a = 100 -1->Emitted(27, 9) Source(20, 17) + SourceIndex(0) -2 >Emitted(27, 27) Source(20, 17) + SourceIndex(0) -3 >Emitted(27, 29) Source(20, 17) + SourceIndex(0) -4 >Emitted(27, 36) Source(20, 24) + SourceIndex(0) +1->Emitted(27, 9) Source(19, 17) + SourceIndex(0) +2 >Emitted(27, 27) Source(19, 17) + SourceIndex(0) +3 >Emitted(27, 29) Source(19, 17) + SourceIndex(0) +4 >Emitted(27, 36) Source(19, 24) + SourceIndex(0) --- >>> var _this = _super.call(this, a) || this; 1->^^^^^^^^ @@ -299,12 +298,12 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > else > return null; > } -1->Emitted(28, 9) Source(20, 5) + SourceIndex(0) -2 >Emitted(28, 21) Source(21, 9) + SourceIndex(0) -3 >Emitted(28, 39) Source(21, 15) + SourceIndex(0) -4 >Emitted(28, 40) Source(21, 16) + SourceIndex(0) -5 >Emitted(28, 41) Source(21, 17) + SourceIndex(0) -6 >Emitted(28, 50) Source(33, 6) + SourceIndex(0) +1->Emitted(28, 9) Source(19, 5) + SourceIndex(0) +2 >Emitted(28, 21) Source(20, 9) + SourceIndex(0) +3 >Emitted(28, 39) Source(20, 15) + SourceIndex(0) +4 >Emitted(28, 40) Source(20, 16) + SourceIndex(0) +5 >Emitted(28, 41) Source(20, 17) + SourceIndex(0) +6 >Emitted(28, 50) Source(32, 6) + SourceIndex(0) --- >>> _this.dProp = function () { return _this; }; 1->^^^^^^^^ @@ -325,15 +324,15 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 7 > 8 > this 9 > ; -1->Emitted(29, 9) Source(18, 5) + SourceIndex(0) -2 >Emitted(29, 20) Source(18, 10) + SourceIndex(0) -3 >Emitted(29, 23) Source(18, 13) + SourceIndex(0) -4 >Emitted(29, 37) Source(18, 19) + SourceIndex(0) -5 >Emitted(29, 44) Source(18, 19) + SourceIndex(0) -6 >Emitted(29, 49) Source(18, 23) + SourceIndex(0) -7 >Emitted(29, 51) Source(18, 19) + SourceIndex(0) -8 >Emitted(29, 52) Source(18, 23) + SourceIndex(0) -9 >Emitted(29, 53) Source(18, 24) + SourceIndex(0) +1->Emitted(29, 9) Source(17, 5) + SourceIndex(0) +2 >Emitted(29, 20) Source(17, 10) + SourceIndex(0) +3 >Emitted(29, 23) Source(17, 13) + SourceIndex(0) +4 >Emitted(29, 37) Source(17, 19) + SourceIndex(0) +5 >Emitted(29, 44) Source(17, 19) + SourceIndex(0) +6 >Emitted(29, 49) Source(17, 23) + SourceIndex(0) +7 >Emitted(29, 51) Source(17, 19) + SourceIndex(0) +8 >Emitted(29, 52) Source(17, 23) + SourceIndex(0) +9 >Emitted(29, 53) Source(17, 24) + SourceIndex(0) --- >>> if (Math.random() < 0.5) { 1 >^^^^^^^^ @@ -367,19 +366,19 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 11> ) 12> 13> { -1 >Emitted(30, 9) Source(23, 9) + SourceIndex(0) -2 >Emitted(30, 11) Source(23, 11) + SourceIndex(0) -3 >Emitted(30, 12) Source(23, 12) + SourceIndex(0) -4 >Emitted(30, 13) Source(23, 13) + SourceIndex(0) -5 >Emitted(30, 17) Source(23, 17) + SourceIndex(0) -6 >Emitted(30, 18) Source(23, 18) + SourceIndex(0) -7 >Emitted(30, 24) Source(23, 24) + SourceIndex(0) -8 >Emitted(30, 26) Source(23, 26) + SourceIndex(0) -9 >Emitted(30, 29) Source(23, 29) + SourceIndex(0) -10>Emitted(30, 32) Source(23, 32) + SourceIndex(0) -11>Emitted(30, 33) Source(23, 33) + SourceIndex(0) -12>Emitted(30, 34) Source(23, 34) + SourceIndex(0) -13>Emitted(30, 35) Source(23, 35) + SourceIndex(0) +1 >Emitted(30, 9) Source(22, 9) + SourceIndex(0) +2 >Emitted(30, 11) Source(22, 11) + SourceIndex(0) +3 >Emitted(30, 12) Source(22, 12) + SourceIndex(0) +4 >Emitted(30, 13) Source(22, 13) + SourceIndex(0) +5 >Emitted(30, 17) Source(22, 17) + SourceIndex(0) +6 >Emitted(30, 18) Source(22, 18) + SourceIndex(0) +7 >Emitted(30, 24) Source(22, 24) + SourceIndex(0) +8 >Emitted(30, 26) Source(22, 26) + SourceIndex(0) +9 >Emitted(30, 29) Source(22, 29) + SourceIndex(0) +10>Emitted(30, 32) Source(22, 32) + SourceIndex(0) +11>Emitted(30, 33) Source(22, 33) + SourceIndex(0) +12>Emitted(30, 34) Source(22, 34) + SourceIndex(0) +13>Emitted(30, 35) Source(22, 35) + SourceIndex(0) --- >>> "You win!"; 1 >^^^^^^^^^^^^ @@ -389,9 +388,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > "You win!" 3 > -1 >Emitted(31, 13) Source(24, 13) + SourceIndex(0) -2 >Emitted(31, 23) Source(24, 23) + SourceIndex(0) -3 >Emitted(31, 24) Source(24, 23) + SourceIndex(0) +1 >Emitted(31, 13) Source(23, 13) + SourceIndex(0) +2 >Emitted(31, 23) Source(23, 23) + SourceIndex(0) +3 >Emitted(31, 24) Source(23, 23) + SourceIndex(0) --- >>> return { 1 >^^^^^^^^^^^^ @@ -402,9 +401,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > return 3 > -1 >Emitted(32, 13) Source(25, 13) + SourceIndex(0) -2 >Emitted(32, 19) Source(25, 19) + SourceIndex(0) -3 >Emitted(32, 20) Source(25, 20) + SourceIndex(0) +1 >Emitted(32, 13) Source(24, 13) + SourceIndex(0) +2 >Emitted(32, 19) Source(24, 19) + SourceIndex(0) +3 >Emitted(32, 20) Source(24, 20) + SourceIndex(0) --- >>> cProp: 1, 1->^^^^^^^^^^^^^^^^ @@ -417,10 +416,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 2 > cProp 3 > : 4 > 1 -1->Emitted(33, 17) Source(26, 17) + SourceIndex(0) -2 >Emitted(33, 22) Source(26, 22) + SourceIndex(0) -3 >Emitted(33, 24) Source(26, 24) + SourceIndex(0) -4 >Emitted(33, 25) Source(26, 25) + SourceIndex(0) +1->Emitted(33, 17) Source(25, 17) + SourceIndex(0) +2 >Emitted(33, 22) Source(25, 22) + SourceIndex(0) +3 >Emitted(33, 24) Source(25, 24) + SourceIndex(0) +4 >Emitted(33, 25) Source(25, 25) + SourceIndex(0) --- >>> dProp: function () { return _this; }, 1->^^^^^^^^^^^^^^^^ @@ -441,14 +440,14 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 6 > this 7 > 8 > this -1->Emitted(34, 17) Source(27, 17) + SourceIndex(0) -2 >Emitted(34, 22) Source(27, 22) + SourceIndex(0) -3 >Emitted(34, 24) Source(27, 24) + SourceIndex(0) -4 >Emitted(34, 38) Source(27, 30) + SourceIndex(0) -5 >Emitted(34, 45) Source(27, 30) + SourceIndex(0) -6 >Emitted(34, 50) Source(27, 34) + SourceIndex(0) -7 >Emitted(34, 52) Source(27, 30) + SourceIndex(0) -8 >Emitted(34, 53) Source(27, 34) + SourceIndex(0) +1->Emitted(34, 17) Source(26, 17) + SourceIndex(0) +2 >Emitted(34, 22) Source(26, 22) + SourceIndex(0) +3 >Emitted(34, 24) Source(26, 24) + SourceIndex(0) +4 >Emitted(34, 38) Source(26, 30) + SourceIndex(0) +5 >Emitted(34, 45) Source(26, 30) + SourceIndex(0) +6 >Emitted(34, 50) Source(26, 34) + SourceIndex(0) +7 >Emitted(34, 52) Source(26, 30) + SourceIndex(0) +8 >Emitted(34, 53) Source(26, 34) + SourceIndex(0) --- >>> foo: function () { return "You win!!!!!"; } 1->^^^^^^^^^^^^^^^^ @@ -470,15 +469,15 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 7 > 8 > 9 > } -1->Emitted(35, 17) Source(28, 17) + SourceIndex(0) -2 >Emitted(35, 20) Source(28, 20) + SourceIndex(0) -3 >Emitted(35, 36) Source(28, 25) + SourceIndex(0) -4 >Emitted(35, 42) Source(28, 31) + SourceIndex(0) -5 >Emitted(35, 43) Source(28, 32) + SourceIndex(0) -6 >Emitted(35, 57) Source(28, 46) + SourceIndex(0) -7 >Emitted(35, 58) Source(28, 46) + SourceIndex(0) -8 >Emitted(35, 59) Source(28, 47) + SourceIndex(0) -9 >Emitted(35, 60) Source(28, 48) + SourceIndex(0) +1->Emitted(35, 17) Source(27, 17) + SourceIndex(0) +2 >Emitted(35, 20) Source(27, 20) + SourceIndex(0) +3 >Emitted(35, 36) Source(27, 25) + SourceIndex(0) +4 >Emitted(35, 42) Source(27, 31) + SourceIndex(0) +5 >Emitted(35, 43) Source(27, 32) + SourceIndex(0) +6 >Emitted(35, 57) Source(27, 46) + SourceIndex(0) +7 >Emitted(35, 58) Source(27, 46) + SourceIndex(0) +8 >Emitted(35, 59) Source(27, 47) + SourceIndex(0) +9 >Emitted(35, 60) Source(27, 48) + SourceIndex(0) --- >>> }; 1 >^^^^^^^^^^^^^ @@ -486,8 +485,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > } 2 > ; -1 >Emitted(36, 14) Source(29, 14) + SourceIndex(0) -2 >Emitted(36, 15) Source(29, 15) + SourceIndex(0) +1 >Emitted(36, 14) Source(28, 14) + SourceIndex(0) +2 >Emitted(36, 15) Source(28, 15) + SourceIndex(0) --- >>> } 1 >^^^^^^^^ @@ -496,8 +495,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(37, 9) Source(30, 9) + SourceIndex(0) -2 >Emitted(37, 10) Source(30, 10) + SourceIndex(0) +1 >Emitted(37, 9) Source(29, 9) + SourceIndex(0) +2 >Emitted(37, 10) Source(29, 10) + SourceIndex(0) --- >>> else 1->^^^^^^^^ @@ -506,8 +505,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1-> > 2 > else -1->Emitted(38, 9) Source(31, 9) + SourceIndex(0) -2 >Emitted(38, 13) Source(31, 13) + SourceIndex(0) +1->Emitted(38, 9) Source(30, 9) + SourceIndex(0) +2 >Emitted(38, 13) Source(30, 13) + SourceIndex(0) --- >>> return null; 1->^^^^^^^^^^^^ @@ -521,11 +520,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 3 > 4 > null 5 > ; -1->Emitted(39, 13) Source(32, 13) + SourceIndex(0) -2 >Emitted(39, 19) Source(32, 19) + SourceIndex(0) -3 >Emitted(39, 20) Source(32, 20) + SourceIndex(0) -4 >Emitted(39, 24) Source(32, 24) + SourceIndex(0) -5 >Emitted(39, 25) Source(32, 25) + SourceIndex(0) +1->Emitted(39, 13) Source(31, 13) + SourceIndex(0) +2 >Emitted(39, 19) Source(31, 19) + SourceIndex(0) +3 >Emitted(39, 20) Source(31, 20) + SourceIndex(0) +4 >Emitted(39, 24) Source(31, 24) + SourceIndex(0) +5 >Emitted(39, 25) Source(31, 25) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -534,8 +533,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(40, 5) Source(33, 5) + SourceIndex(0) -2 >Emitted(40, 6) Source(33, 6) + SourceIndex(0) +1 >Emitted(40, 5) Source(32, 5) + SourceIndex(0) +2 >Emitted(40, 6) Source(32, 6) + SourceIndex(0) --- >>> return D; 1->^^^^ @@ -543,8 +542,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1-> > 2 > } -1->Emitted(41, 5) Source(34, 1) + SourceIndex(0) -2 >Emitted(41, 13) Source(34, 2) + SourceIndex(0) +1->Emitted(41, 5) Source(33, 1) + SourceIndex(0) +2 >Emitted(41, 13) Source(33, 2) + SourceIndex(0) --- >>>}(C)); 1 > @@ -577,11 +576,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > return null; > } > } -1 >Emitted(42, 1) Source(34, 1) + SourceIndex(0) -2 >Emitted(42, 2) Source(34, 2) + SourceIndex(0) -3 >Emitted(42, 2) Source(17, 1) + SourceIndex(0) -4 >Emitted(42, 3) Source(17, 17) + SourceIndex(0) -5 >Emitted(42, 4) Source(17, 18) + SourceIndex(0) -6 >Emitted(42, 7) Source(34, 2) + SourceIndex(0) +1 >Emitted(42, 1) Source(33, 1) + SourceIndex(0) +2 >Emitted(42, 2) Source(33, 2) + SourceIndex(0) +3 >Emitted(42, 2) Source(16, 1) + SourceIndex(0) +4 >Emitted(42, 3) Source(16, 17) + SourceIndex(0) +5 >Emitted(42, 4) Source(16, 18) + SourceIndex(0) +6 >Emitted(42, 7) Source(33, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=derivedClassConstructorWithExplicitReturns01.js.map \ No newline at end of file diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols index ee043fcfe71..a8545de2ba1 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols @@ -1,24 +1,23 @@ === tests/cases/compiler/derivedClassConstructorWithExplicitReturns01.ts === - class C { >C : Symbol(C, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 0)) cProp = 10; ->cProp : Symbol(C.cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 1, 9)) +>cProp : Symbol(C.cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 9)) foo() { return "this never gets used."; } ->foo : Symbol(C.foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 2, 15)) +>foo : Symbol(C.foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 1, 15)) constructor(value: number) { ->value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 6, 16)) +>value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 5, 16)) return { cProp: value, ->cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 7, 16)) ->value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 6, 16)) +>cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 6, 16)) +>value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 5, 16)) foo() { ->foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 8, 25)) +>foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 7, 25)) return "well this looks kinda C-ish."; } @@ -27,19 +26,19 @@ class C { } class D extends C { ->D : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 14, 1)) +>D : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 13, 1)) >C : Symbol(C, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 0)) dProp = () => this; ->dProp : Symbol(D.dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 16, 19)) ->this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 14, 1)) +>dProp : Symbol(D.dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 15, 19)) +>this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 13, 1)) constructor(a = 100) { ->a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 19, 16)) +>a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 18, 16)) super(a); >super : Symbol(C, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 0)) ->a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 19, 16)) +>a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 18, 16)) if (Math.random() < 0.5) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -49,14 +48,14 @@ class D extends C { "You win!" return { cProp: 1, ->cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 24, 20)) +>cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 23, 20)) dProp: () => this, ->dProp : Symbol(dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 25, 25)) ->this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 14, 1)) +>dProp : Symbol(dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 24, 25)) +>this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 13, 1)) foo() { return "You win!!!!!" } ->foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 26, 34)) +>foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 25, 34)) }; } diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types index d361e783ef0..dbcac43d5bd 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types @@ -1,5 +1,4 @@ === tests/cases/compiler/derivedClassConstructorWithExplicitReturns01.ts === - class C { >C : C diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers.js b/tests/baselines/reference/derivedClassOverridesProtectedMembers.js index 9230a295f5b..7369354ffd9 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers.js +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers.js @@ -1,5 +1,4 @@ //// [derivedClassOverridesProtectedMembers.ts] - var x: { foo: string; } var y: { foo: string; bar: string; } diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols b/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols index 690916db87c..fbe2b87bcb6 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols @@ -1,122 +1,121 @@ === tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers.ts === - var x: { foo: string; } ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) ->foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 1, 8)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) +>foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 0, 8)) var y: { foo: string; bar: string; } ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) ->foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 2, 8)) ->bar : Symbol(bar, Decl(derivedClassOverridesProtectedMembers.ts, 2, 21)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 1, 8)) +>bar : Symbol(bar, Decl(derivedClassOverridesProtectedMembers.ts, 1, 21)) class Base { ->Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 2, 36)) +>Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 1, 36)) protected a: typeof x; ->a : Symbol(Base.a, Decl(derivedClassOverridesProtectedMembers.ts, 4, 12)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>a : Symbol(Base.a, Decl(derivedClassOverridesProtectedMembers.ts, 3, 12)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected b(a: typeof x) { } ->b : Symbol(Base.b, Decl(derivedClassOverridesProtectedMembers.ts, 5, 26)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 6, 16)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>b : Symbol(Base.b, Decl(derivedClassOverridesProtectedMembers.ts, 4, 26)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 5, 16)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected get c() { return x; } ->c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 6, 32), Decl(derivedClassOverridesProtectedMembers.ts, 7, 35)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 5, 32), Decl(derivedClassOverridesProtectedMembers.ts, 6, 35)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected set c(v: typeof x) { } ->c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 6, 32), Decl(derivedClassOverridesProtectedMembers.ts, 7, 35)) ->v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 8, 20)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 5, 32), Decl(derivedClassOverridesProtectedMembers.ts, 6, 35)) +>v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 7, 20)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected d: (a: typeof x) => void; ->d : Symbol(Base.d, Decl(derivedClassOverridesProtectedMembers.ts, 8, 36)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 9, 18)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>d : Symbol(Base.d, Decl(derivedClassOverridesProtectedMembers.ts, 7, 36)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 8, 18)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static r: typeof x; ->r : Symbol(Base.r, Decl(derivedClassOverridesProtectedMembers.ts, 9, 39)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>r : Symbol(Base.r, Decl(derivedClassOverridesProtectedMembers.ts, 8, 39)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static s(a: typeof x) { } ->s : Symbol(Base.s, Decl(derivedClassOverridesProtectedMembers.ts, 11, 33)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 12, 23)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>s : Symbol(Base.s, Decl(derivedClassOverridesProtectedMembers.ts, 10, 33)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 11, 23)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static get t() { return x; } ->t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 12, 39), Decl(derivedClassOverridesProtectedMembers.ts, 13, 42)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 11, 39), Decl(derivedClassOverridesProtectedMembers.ts, 12, 42)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static set t(v: typeof x) { } ->t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 12, 39), Decl(derivedClassOverridesProtectedMembers.ts, 13, 42)) ->v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 14, 27)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 11, 39), Decl(derivedClassOverridesProtectedMembers.ts, 12, 42)) +>v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 13, 27)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static u: (a: typeof x) => void; ->u : Symbol(Base.u, Decl(derivedClassOverridesProtectedMembers.ts, 14, 43)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 15, 25)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>u : Symbol(Base.u, Decl(derivedClassOverridesProtectedMembers.ts, 13, 43)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 14, 25)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) constructor(a: typeof x) { } ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 17, 16)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 16, 16)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) } class Derived extends Base { ->Derived : Symbol(Derived, Decl(derivedClassOverridesProtectedMembers.ts, 18, 1)) ->Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 2, 36)) +>Derived : Symbol(Derived, Decl(derivedClassOverridesProtectedMembers.ts, 17, 1)) +>Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 1, 36)) protected a: typeof y; ->a : Symbol(Derived.a, Decl(derivedClassOverridesProtectedMembers.ts, 20, 28)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>a : Symbol(Derived.a, Decl(derivedClassOverridesProtectedMembers.ts, 19, 28)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected b(a: typeof y) { } ->b : Symbol(Derived.b, Decl(derivedClassOverridesProtectedMembers.ts, 21, 26)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 22, 16)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>b : Symbol(Derived.b, Decl(derivedClassOverridesProtectedMembers.ts, 20, 26)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 21, 16)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected get c() { return y; } ->c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 22, 32), Decl(derivedClassOverridesProtectedMembers.ts, 23, 35)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 21, 32), Decl(derivedClassOverridesProtectedMembers.ts, 22, 35)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected set c(v: typeof y) { } ->c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 22, 32), Decl(derivedClassOverridesProtectedMembers.ts, 23, 35)) ->v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 24, 20)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 21, 32), Decl(derivedClassOverridesProtectedMembers.ts, 22, 35)) +>v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 23, 20)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected d: (a: typeof y) => void; ->d : Symbol(Derived.d, Decl(derivedClassOverridesProtectedMembers.ts, 24, 36)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 25, 18)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>d : Symbol(Derived.d, Decl(derivedClassOverridesProtectedMembers.ts, 23, 36)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 24, 18)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static r: typeof y; ->r : Symbol(Derived.r, Decl(derivedClassOverridesProtectedMembers.ts, 25, 39)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>r : Symbol(Derived.r, Decl(derivedClassOverridesProtectedMembers.ts, 24, 39)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static s(a: typeof y) { } ->s : Symbol(Derived.s, Decl(derivedClassOverridesProtectedMembers.ts, 27, 33)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 28, 23)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>s : Symbol(Derived.s, Decl(derivedClassOverridesProtectedMembers.ts, 26, 33)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 27, 23)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static get t() { return y; } ->t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 28, 39), Decl(derivedClassOverridesProtectedMembers.ts, 29, 42)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 27, 39), Decl(derivedClassOverridesProtectedMembers.ts, 28, 42)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static set t(a: typeof y) { } ->t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 28, 39), Decl(derivedClassOverridesProtectedMembers.ts, 29, 42)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 30, 27)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 27, 39), Decl(derivedClassOverridesProtectedMembers.ts, 28, 42)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 29, 27)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static u: (a: typeof y) => void; ->u : Symbol(Derived.u, Decl(derivedClassOverridesProtectedMembers.ts, 30, 43)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 31, 25)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>u : Symbol(Derived.u, Decl(derivedClassOverridesProtectedMembers.ts, 29, 43)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 30, 25)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) constructor(a: typeof y) { super(x) } ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 33, 16)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) ->super : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 2, 36)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 32, 16)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>super : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 1, 36)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) } diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers.types b/tests/baselines/reference/derivedClassOverridesProtectedMembers.types index 2695cbabe34..32aca9dd5cb 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers.types +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers.ts === - var x: { foo: string; } >x : { foo: string; } >foo : string diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt index a9762ce03ec..faf228e8d55 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt @@ -1,27 +1,26 @@ -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(23,7): error TS2415: Class 'Derived1' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(22,7): error TS2415: Class 'Derived1' incorrectly extends base class 'Base'. Property 'a' is protected in type 'Derived1' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(28,7): error TS2415: Class 'Derived2' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(27,7): error TS2415: Class 'Derived2' incorrectly extends base class 'Base'. Property 'b' is protected in type 'Derived2' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(33,7): error TS2415: Class 'Derived3' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(32,7): error TS2415: Class 'Derived3' incorrectly extends base class 'Base'. Property 'c' is protected in type 'Derived3' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(38,7): error TS2415: Class 'Derived4' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(37,7): error TS2415: Class 'Derived4' incorrectly extends base class 'Base'. Property 'c' is protected in type 'Derived4' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(43,7): error TS2415: Class 'Derived5' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(42,7): error TS2415: Class 'Derived5' incorrectly extends base class 'Base'. Property 'd' is protected in type 'Derived5' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(48,7): error TS2417: Class static side 'typeof Derived6' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(47,7): error TS2417: Class static side 'typeof Derived6' incorrectly extends base class static side 'typeof Base'. Property 'r' is protected in type 'typeof Derived6' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(53,7): error TS2417: Class static side 'typeof Derived7' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(52,7): error TS2417: Class static side 'typeof Derived7' incorrectly extends base class static side 'typeof Base'. Property 's' is protected in type 'typeof Derived7' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(58,7): error TS2417: Class static side 'typeof Derived8' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(57,7): error TS2417: Class static side 'typeof Derived8' incorrectly extends base class static side 'typeof Base'. Property 't' is protected in type 'typeof Derived8' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(63,7): error TS2417: Class static side 'typeof Derived9' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(62,7): error TS2417: Class static side 'typeof Derived9' incorrectly extends base class static side 'typeof Base'. Property 't' is protected in type 'typeof Derived9' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(68,7): error TS2417: Class static side 'typeof Derived10' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(67,7): error TS2417: Class static side 'typeof Derived10' incorrectly extends base class static side 'typeof Base'. Property 'u' is protected in type 'typeof Derived10' but public in type 'typeof Base'. ==== tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts (10 errors) ==== - var x: { foo: string; } var y: { foo: string; bar: string; } diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js index 615bdcddcf0..c1fcf54d663 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js @@ -1,5 +1,4 @@ //// [derivedClassOverridesProtectedMembers3.ts] - var x: { foo: string; } var y: { foo: string; bar: string; } diff --git a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt index 60054fa47dc..06742e3e720 100644 --- a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt +++ b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateInstanceShadowingProtectedInstance.ts(13,7): error TS2415: Class 'Derived' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateInstanceShadowingProtectedInstance.ts(12,7): error TS2415: Class 'Derived' incorrectly extends base class 'Base'. Property 'x' is private in type 'Derived' but not in type 'Base'. ==== tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateInstanceShadowingProtectedInstance.ts (1 errors) ==== - class Base { protected x: string; protected fn(): string { diff --git a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js index 07cc9c43539..c92a192a864 100644 --- a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js +++ b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js @@ -1,5 +1,4 @@ //// [derivedClassWithPrivateInstanceShadowingProtectedInstance.ts] - class Base { protected x: string; protected fn(): string { diff --git a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt index 2697585cb20..2567c6e8ce0 100644 --- a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt +++ b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateStaticShadowingProtectedStatic.ts(13,7): error TS2417: Class static side 'typeof Derived' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateStaticShadowingProtectedStatic.ts(12,7): error TS2417: Class static side 'typeof Derived' incorrectly extends base class static side 'typeof Base'. Property 'x' is private in type 'typeof Derived' but not in type 'typeof Base'. ==== tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateStaticShadowingProtectedStatic.ts (1 errors) ==== - class Base { protected static x: string; protected static fn(): string { diff --git a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js index 52a50a8aa77..e5310f6d837 100644 --- a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js +++ b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js @@ -1,5 +1,4 @@ //// [derivedClassWithPrivateStaticShadowingProtectedStatic.ts] - class Base { protected static x: string; protected static fn(): string { diff --git a/tests/baselines/reference/destructureOptionalParameter.js b/tests/baselines/reference/destructureOptionalParameter.js index b937d58412f..18239bddc4e 100644 --- a/tests/baselines/reference/destructureOptionalParameter.js +++ b/tests/baselines/reference/destructureOptionalParameter.js @@ -1,5 +1,4 @@ //// [destructureOptionalParameter.ts] - declare function f1({ a, b }?: { a: number, b: string }): void; function f2({ a, b }: { a: number, b: number } = { a: 0, b: 0 }) { diff --git a/tests/baselines/reference/destructureOptionalParameter.symbols b/tests/baselines/reference/destructureOptionalParameter.symbols index aa5252680cc..d75722076a9 100644 --- a/tests/baselines/reference/destructureOptionalParameter.symbols +++ b/tests/baselines/reference/destructureOptionalParameter.symbols @@ -1,69 +1,68 @@ === tests/cases/compiler/destructureOptionalParameter.ts === - declare function f1({ a, b }?: { a: number, b: string }): void; >f1 : Symbol(f1, Decl(destructureOptionalParameter.ts, 0, 0)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 1, 21)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 1, 24)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 1, 32)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 1, 43)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 0, 21)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 0, 24)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 0, 32)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 0, 43)) function f2({ a, b }: { a: number, b: number } = { a: 0, b: 0 }) { ->f2 : Symbol(f2, Decl(destructureOptionalParameter.ts, 1, 63)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 13)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 16)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 23)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 34)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 50)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 56)) +>f2 : Symbol(f2, Decl(destructureOptionalParameter.ts, 0, 63)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 13)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 16)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 23)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 34)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 50)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 56)) a; ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 13)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 13)) b; ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 16)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 16)) } // Repro from #8681 interface Type { t: void } ->Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 6, 1)) ->t : Symbol(Type.t, Decl(destructureOptionalParameter.ts, 10, 16)) +>Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 5, 1)) +>t : Symbol(Type.t, Decl(destructureOptionalParameter.ts, 9, 16)) interface QueryMetadata { q: void } ->QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 10, 26)) ->q : Symbol(QueryMetadata.q, Decl(destructureOptionalParameter.ts, 11, 25)) +>QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 9, 26)) +>q : Symbol(QueryMetadata.q, Decl(destructureOptionalParameter.ts, 10, 25)) interface QueryMetadataFactory { ->QueryMetadataFactory : Symbol(QueryMetadataFactory, Decl(destructureOptionalParameter.ts, 11, 35)) +>QueryMetadataFactory : Symbol(QueryMetadataFactory, Decl(destructureOptionalParameter.ts, 10, 35)) (selector: Type | string, {descendants, read}?: { ->selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 14, 5)) ->Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 6, 1)) ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 14, 31)) ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 14, 43)) +>selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 13, 5)) +>Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 5, 1)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 13, 31)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 13, 43)) descendants?: boolean; ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 14, 53)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 13, 53)) read?: any; ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 15, 30)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 14, 30)) }): ParameterDecorator; >ParameterDecorator : Symbol(ParameterDecorator, Decl(lib.d.ts, --, --)) new (selector: Type | string, {descendants, read}?: { ->selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 18, 9)) ->Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 6, 1)) ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 18, 35)) ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 18, 47)) +>selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 17, 9)) +>Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 5, 1)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 17, 35)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 17, 47)) descendants?: boolean; ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 18, 57)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 17, 57)) read?: any; ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 19, 30)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 18, 30)) }): QueryMetadata; ->QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 10, 26)) +>QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 9, 26)) } diff --git a/tests/baselines/reference/destructureOptionalParameter.types b/tests/baselines/reference/destructureOptionalParameter.types index a72b03f5939..f007a992c9e 100644 --- a/tests/baselines/reference/destructureOptionalParameter.types +++ b/tests/baselines/reference/destructureOptionalParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/destructureOptionalParameter.ts === - declare function f1({ a, b }?: { a: number, b: string }): void; >f1 : ({a, b}?: { a: number; b: string; } | undefined) => void >a : number diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt index beefbc9a85b..4dc6085e662 100644 --- a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(44,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(45,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(45,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(43,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(44,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(44,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ==== tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts (3 errors) ==== - /* AssignmentPattern: * ObjectAssignmentPattern * ArrayAssignmentPattern diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js index d3a5c9ff5aa..f6438ba8b65 100644 --- a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js @@ -1,5 +1,4 @@ //// [destructuringArrayBindingPatternAndAssignment1ES6.ts] - /* AssignmentPattern: * ObjectAssignmentPattern * ArrayAssignmentPattern diff --git a/tests/baselines/reference/destructuringCatch.js b/tests/baselines/reference/destructuringCatch.js index 4593b22f127..8a10c01f6f8 100644 --- a/tests/baselines/reference/destructuringCatch.js +++ b/tests/baselines/reference/destructuringCatch.js @@ -1,5 +1,4 @@ //// [destructuringCatch.ts] - try { throw [0, 1]; } diff --git a/tests/baselines/reference/destructuringCatch.symbols b/tests/baselines/reference/destructuringCatch.symbols index 1d0a954b377..a78beb8d776 100644 --- a/tests/baselines/reference/destructuringCatch.symbols +++ b/tests/baselines/reference/destructuringCatch.symbols @@ -1,51 +1,50 @@ === tests/cases/conformance/es6/destructuring/destructuringCatch.ts === - try { throw [0, 1]; } catch ([a, b]) { ->a : Symbol(a, Decl(destructuringCatch.ts, 4, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 4, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 3, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 3, 10)) a + b; ->a : Symbol(a, Decl(destructuringCatch.ts, 4, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 4, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 3, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 3, 10)) } try { throw { a: 0, b: 1 }; ->a : Symbol(a, Decl(destructuringCatch.ts, 9, 11)) ->b : Symbol(b, Decl(destructuringCatch.ts, 9, 17)) +>a : Symbol(a, Decl(destructuringCatch.ts, 8, 11)) +>b : Symbol(b, Decl(destructuringCatch.ts, 8, 17)) } catch ({a, b}) { ->a : Symbol(a, Decl(destructuringCatch.ts, 11, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 11, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 10, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 10, 10)) a + b; ->a : Symbol(a, Decl(destructuringCatch.ts, 11, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 11, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 10, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 10, 10)) } try { throw [{ x: [0], z: 1 }]; ->x : Symbol(x, Decl(destructuringCatch.ts, 16, 12)) ->z : Symbol(z, Decl(destructuringCatch.ts, 16, 20)) +>x : Symbol(x, Decl(destructuringCatch.ts, 15, 12)) +>z : Symbol(z, Decl(destructuringCatch.ts, 15, 20)) } catch ([{x: [y], z}]) { >x : Symbol(x) ->y : Symbol(y, Decl(destructuringCatch.ts, 18, 13)) ->z : Symbol(z, Decl(destructuringCatch.ts, 18, 16)) +>y : Symbol(y, Decl(destructuringCatch.ts, 17, 13)) +>z : Symbol(z, Decl(destructuringCatch.ts, 17, 16)) y + z; ->y : Symbol(y, Decl(destructuringCatch.ts, 18, 13)) ->z : Symbol(z, Decl(destructuringCatch.ts, 18, 16)) +>y : Symbol(y, Decl(destructuringCatch.ts, 17, 13)) +>z : Symbol(z, Decl(destructuringCatch.ts, 17, 16)) } // Test of comment ranges. A fix to GH#11755 should update this. try { } catch (/*Test comment ranges*/[/*a*/a]) { ->a : Symbol(a, Decl(destructuringCatch.ts, 25, 31)) +>a : Symbol(a, Decl(destructuringCatch.ts, 24, 31)) } diff --git a/tests/baselines/reference/destructuringCatch.types b/tests/baselines/reference/destructuringCatch.types index 3f057e64e4e..c2a9b9f45c0 100644 --- a/tests/baselines/reference/destructuringCatch.types +++ b/tests/baselines/reference/destructuringCatch.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringCatch.ts === - try { throw [0, 1]; >[0, 1] : number[] diff --git a/tests/baselines/reference/destructuringInFunctionType.js b/tests/baselines/reference/destructuringInFunctionType.js index ac187f5b43d..8490a14c91e 100644 --- a/tests/baselines/reference/destructuringInFunctionType.js +++ b/tests/baselines/reference/destructuringInFunctionType.js @@ -1,5 +1,4 @@ //// [destructuringInFunctionType.ts] - interface a { a } interface b { b } interface c { c } diff --git a/tests/baselines/reference/destructuringInFunctionType.symbols b/tests/baselines/reference/destructuringInFunctionType.symbols index d73215a2ce6..de4645753ef 100644 --- a/tests/baselines/reference/destructuringInFunctionType.symbols +++ b/tests/baselines/reference/destructuringInFunctionType.symbols @@ -1,78 +1,77 @@ === tests/cases/conformance/es6/destructuring/destructuringInFunctionType.ts === - interface a { a } >a : Symbol(a, Decl(destructuringInFunctionType.ts, 0, 0)) ->a : Symbol(a.a, Decl(destructuringInFunctionType.ts, 1, 13)) +>a : Symbol(a.a, Decl(destructuringInFunctionType.ts, 0, 13)) interface b { b } ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->b : Symbol(b.b, Decl(destructuringInFunctionType.ts, 2, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>b : Symbol(b.b, Decl(destructuringInFunctionType.ts, 1, 13)) interface c { c } ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 2, 17)) ->c : Symbol(c.c, Decl(destructuringInFunctionType.ts, 3, 13)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 1, 17)) +>c : Symbol(c.c, Decl(destructuringInFunctionType.ts, 2, 13)) type T1 = ([a, b, c]); ->T1 : Symbol(T1, Decl(destructuringInFunctionType.ts, 3, 17)) +>T1 : Symbol(T1, Decl(destructuringInFunctionType.ts, 2, 17)) >a : Symbol(a, Decl(destructuringInFunctionType.ts, 0, 0)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 2, 17)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 1, 17)) type F1 = ([a, b, c]) => void; ->F1 : Symbol(F1, Decl(destructuringInFunctionType.ts, 5, 22)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 6, 12)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 6, 14)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 6, 17)) +>F1 : Symbol(F1, Decl(destructuringInFunctionType.ts, 4, 22)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 5, 12)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 5, 14)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 5, 17)) type T2 = ({ a }); ->T2 : Symbol(T2, Decl(destructuringInFunctionType.ts, 6, 30)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 8, 12)) +>T2 : Symbol(T2, Decl(destructuringInFunctionType.ts, 5, 30)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 7, 12)) type F2 = ({ a }) => void; ->F2 : Symbol(F2, Decl(destructuringInFunctionType.ts, 8, 18)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 9, 12)) +>F2 : Symbol(F2, Decl(destructuringInFunctionType.ts, 7, 18)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 8, 12)) type T3 = ([{ a: b }, { b: a }]); ->T3 : Symbol(T3, Decl(destructuringInFunctionType.ts, 9, 26)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 11, 13)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 11, 23)) +>T3 : Symbol(T3, Decl(destructuringInFunctionType.ts, 8, 26)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 10, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 10, 23)) >a : Symbol(a, Decl(destructuringInFunctionType.ts, 0, 0)) type F3 = ([{ a: b }, { b: a }]) => void; ->F3 : Symbol(F3, Decl(destructuringInFunctionType.ts, 11, 33)) +>F3 : Symbol(F3, Decl(destructuringInFunctionType.ts, 10, 33)) >a : Symbol(a) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 12, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 11, 13)) >b : Symbol(b) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 12, 23)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 11, 23)) type T4 = ([{ a: [b, c] }]); ->T4 : Symbol(T4, Decl(destructuringInFunctionType.ts, 12, 41)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 14, 13)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 2, 17)) +>T4 : Symbol(T4, Decl(destructuringInFunctionType.ts, 11, 41)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 13, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 1, 17)) type F4 = ([{ a: [b, c] }]) => void; ->F4 : Symbol(F4, Decl(destructuringInFunctionType.ts, 14, 28)) +>F4 : Symbol(F4, Decl(destructuringInFunctionType.ts, 13, 28)) >a : Symbol(a) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 15, 18)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 15, 20)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 14, 18)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 14, 20)) type C1 = new ([{ a: [b, c] }]) => void; ->C1 : Symbol(C1, Decl(destructuringInFunctionType.ts, 15, 36)) +>C1 : Symbol(C1, Decl(destructuringInFunctionType.ts, 14, 36)) >a : Symbol(a) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 17, 22)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 17, 24)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 16, 22)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 16, 24)) var v1 = ([a, b, c]) => "hello"; ->v1 : Symbol(v1, Decl(destructuringInFunctionType.ts, 19, 3)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 19, 11)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 19, 13)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 19, 16)) +>v1 : Symbol(v1, Decl(destructuringInFunctionType.ts, 18, 3)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 18, 11)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 18, 13)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 18, 16)) var v2: ([a, b, c]) => string; ->v2 : Symbol(v2, Decl(destructuringInFunctionType.ts, 20, 3)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 20, 10)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 20, 12)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 20, 15)) +>v2 : Symbol(v2, Decl(destructuringInFunctionType.ts, 19, 3)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 19, 10)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 19, 12)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 19, 15)) diff --git a/tests/baselines/reference/destructuringInFunctionType.types b/tests/baselines/reference/destructuringInFunctionType.types index 3f635d44568..09887f5d45a 100644 --- a/tests/baselines/reference/destructuringInFunctionType.types +++ b/tests/baselines/reference/destructuringInFunctionType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringInFunctionType.ts === - interface a { a } >a : a >a : any diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.js b/tests/baselines/reference/destructuringParameterDeclaration3ES5.js index 5dea671ee1a..08dfa25a4d4 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.js +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration3ES5.ts] - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols index b9bf9ee54e2..93faef8af64 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -12,134 +11,134 @@ type arrayString = Array >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type someArray = Array | number[]; ->someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32)) +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 6, 32)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type stringOrNumArray = Array; ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 42)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) function a1(...x: (number|string)[]) { } ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 9, 45)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 11, 12)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 8, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 10, 12)) function a2(...a) { } ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 11, 40)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 12, 12)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 10, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 11, 12)) function a3(...a: Array) { } ->a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 11, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 12, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) function a4(...a: arrayString) { } ->a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 14, 12)) +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 12, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0)) function a5(...a: stringOrNumArray) { } ->a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5.ts, 14, 34)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 15, 12)) ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5.ts, 13, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 14, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 42)) function a9([a, b, [[c]]]) { } ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 15, 39)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 16, 13)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 16, 15)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 16, 21)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 14, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 15, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 15, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 15, 21)) function a10([a, b, [[c]], ...x]) { } ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 17, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 17, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 17, 22)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 17, 26)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 16, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 16, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 16, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 16, 26)) function a11([a, b, c, ...x]: number[]) { } ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 17, 37)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 18, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 18, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 18, 19)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 18, 22)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 16, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 17, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 17, 22)) var array = [1, 2, 3]; ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 20, 3)) var array2 = [true, false, "hello"]; ->array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5.ts, 22, 3)) +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) a2([...array]); ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 11, 40)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 10, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 20, 3)) a1(...array); ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 9, 45)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 8, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 20, 3)) a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 15, 39)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 14, 39)) a10([1, 2, [["string"]], false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) a10([1, 2, 3, false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) a10([1, 2]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) a11([1, 2]); // Parameter type is number[] ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 17, 37)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 16, 37)) // Rest parameter with generic function foo(...a: T[]) { } ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 31, 12)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 34, 13)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 34, 16)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 34, 13)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 30, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 33, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 33, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 33, 13)) foo("hello", 1, 2); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 30, 12)) foo("hello", "world"); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 30, 12)) enum E { a, b } ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 8)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 37, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 37, 11)) const enum E1 { a, b } ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 15)) ->b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5.ts, 39, 18)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 18)) function foo1(...a: T[]) { } ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 39, 14)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 40, 32)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 39, 14)) foo1(1, 2, 3, E.a); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) ->E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 8)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 8)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 37, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 37, 8)) foo1(1, 2, 3, E1.a, E.b); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) ->E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 15)) ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 15)) ->E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 11)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 36, 22)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 11)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 37, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 35, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 37, 11)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types index 7d4662100ed..a91d54d5284 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js index ab00e874e3e..087bf87aaea 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration3ES5iterable.ts] - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols index 52b2d290fa0..8ce99051801 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5iterable.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -12,134 +11,134 @@ type arrayString = Array >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type someArray = Array | number[]; ->someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 32)) +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 6, 32)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type stringOrNumArray = Array; ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 42)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 42)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function a1(...x: (number|string)[]) { } ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 9, 45)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 12)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 10, 12)) function a2(...a) { } ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 40)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 12)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 10, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 12)) function a3(...a: Array) { } ->a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 21)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 12)) +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 12)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function a4(...a: arrayString) { } ->a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 36)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 12)) +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 12)) >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5iterable.ts, 0, 0)) function a5(...a: stringOrNumArray) { } ->a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 34)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 12)) ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 42)) +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 42)) function a9([a, b, [[c]]]) { } ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 39)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 13)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 15)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 21)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 21)) function a10([a, b, [[c]], ...x]) { } ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 22)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 26)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 26)) function a11([a, b, c, ...x]: number[]) { } ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 37)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 19)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 22)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 22)) var array = [1, 2, 3]; ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 20, 3)) var array2 = [true, false, "hello"]; ->array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 22, 3)) +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) a2([...array]); ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 40)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 10, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 20, 3)) a1(...array); ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 9, 45)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 20, 3)) a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 39)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 39)) a10([1, 2, [["string"]], false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) a10([1, 2, 3, false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) a10([1, 2]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) a11([1, 2]); // Parameter type is number[] ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 37)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 37)) // Rest parameter with generic function foo(...a: T[]) { } ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 13)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 16)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 13)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 30, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 33, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 33, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 33, 13)) foo("hello", 1, 2); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 30, 12)) foo("hello", "world"); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 30, 12)) enum E { a, b } ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 11)) const enum E1 { a, b } ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) ->b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 18)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 18)) function foo1(...a: T[]) { } ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 14)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 14)) >Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 32)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 14)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 14)) foo1(1, 2, 3, E.a); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) ->E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 8)) foo1(1, 2, 3, E1.a, E.b); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) ->E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) ->E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 35, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 11)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types index d003531c67b..5f2963abe87 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5iterable.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.js b/tests/baselines/reference/destructuringParameterDeclaration3ES6.js index 5893168bf93..2857cb2276b 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.js +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration3ES6.ts] - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols index e372d6d02a3..6d205bdde88 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES6.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -12,134 +11,134 @@ type arrayString = Array >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type someArray = Array | number[]; ->someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32)) +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 6, 32)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type stringOrNumArray = Array; ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 42)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) function a1(...x: (number|string)[]) { } ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 9, 45)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 11, 12)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 8, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 10, 12)) function a2(...a) { } ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 11, 40)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 12, 12)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 10, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 11, 12)) function a3(...a: Array) { } ->a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 11, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 12, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) function a4(...a: arrayString) { } ->a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 14, 12)) +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 12, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0)) function a5(...a: stringOrNumArray) { } ->a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES6.ts, 14, 34)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 15, 12)) ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES6.ts, 13, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 14, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 42)) function a9([a, b, [[c]]]) { } ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 15, 39)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 16, 13)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 16, 15)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 16, 21)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 14, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 15, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 15, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 15, 21)) function a10([a, b, [[c]], ...x]) { } ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 17, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 17, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 17, 22)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 17, 26)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 16, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 16, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 16, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 16, 26)) function a11([a, b, c, ...x]: number[]) { } ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 17, 37)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 18, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 18, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 18, 19)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 18, 22)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 16, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 17, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 17, 22)) var array = [1, 2, 3]; ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 20, 3)) var array2 = [true, false, "hello"]; ->array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES6.ts, 22, 3)) +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) a2([...array]); ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 11, 40)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 10, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 20, 3)) a1(...array); ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 9, 45)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 8, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 20, 3)) a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 15, 39)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 14, 39)) a10([1, 2, [["string"]], false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) a10([1, 2, 3, false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) a10([1, 2]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) a11([1, 2]); // Parameter type is number[] ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 17, 37)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 16, 37)) // Rest parameter with generic function foo(...a: T[]) { } ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 31, 12)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 34, 13)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 34, 16)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 34, 13)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 30, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 33, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 33, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 33, 13)) foo("hello", 1, 2); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 30, 12)) foo("hello", "world"); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 30, 12)) enum E { a, b } ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 8)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 37, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 37, 11)) const enum E1 { a, b } ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 15)) ->b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES6.ts, 39, 18)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 18)) function foo1(...a: T[]) { } ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 39, 14)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 40, 32)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 39, 14)) foo1(1, 2, 3, E.a); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) ->E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 8)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 8)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 37, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 37, 8)) foo1(1, 2, 3, E1.a, E.b); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) ->E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 15)) ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 15)) ->E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 11)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 36, 22)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 11)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 37, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 35, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 37, 11)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types index 8ec0a27850b..397ec934a2f 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES6.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5.js b/tests/baselines/reference/destructuringParameterDeclaration7ES5.js index f9dac1ae2fa..30ec04d2a66 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5.js +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration7ES5.ts] - interface ISomething { foo: string, bar: string diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols index 44709f18e1b..a2a43a91605 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols @@ -1,33 +1,32 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5.ts === - interface ISomething { >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5.ts, 0, 0)) foo: string, ->foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5.ts, 1, 22)) +>foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5.ts, 0, 22)) bar: string ->bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5.ts, 2, 16)) +>bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5.ts, 1, 16)) } function foo({}, {foo, bar}: ISomething) {} ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 4, 1)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 6, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 6, 22)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 3, 1)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 5, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 5, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5.ts, 0, 0)) function baz([], {foo, bar}: ISomething) {} ->baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5.ts, 6, 43)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 8, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 8, 22)) +>baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5.ts, 5, 43)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 7, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 7, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5.ts, 0, 0)) function one([], {}) {} ->one : Symbol(one, Decl(destructuringParameterDeclaration7ES5.ts, 8, 43)) +>one : Symbol(one, Decl(destructuringParameterDeclaration7ES5.ts, 7, 43)) function two([], [a, b, c]: number[]) {} ->two : Symbol(two, Decl(destructuringParameterDeclaration7ES5.ts, 10, 23)) ->a : Symbol(a, Decl(destructuringParameterDeclaration7ES5.ts, 12, 18)) ->b : Symbol(b, Decl(destructuringParameterDeclaration7ES5.ts, 12, 20)) ->c : Symbol(c, Decl(destructuringParameterDeclaration7ES5.ts, 12, 23)) +>two : Symbol(two, Decl(destructuringParameterDeclaration7ES5.ts, 9, 23)) +>a : Symbol(a, Decl(destructuringParameterDeclaration7ES5.ts, 11, 18)) +>b : Symbol(b, Decl(destructuringParameterDeclaration7ES5.ts, 11, 20)) +>c : Symbol(c, Decl(destructuringParameterDeclaration7ES5.ts, 11, 23)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5.types b/tests/baselines/reference/destructuringParameterDeclaration7ES5.types index 7d64383b0b6..502a176596a 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5.types +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5.ts === - interface ISomething { >ISomething : ISomething diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js index 818ea428c1d..5a357aaef64 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration7ES5iterable.ts] - interface ISomething { foo: string, bar: string diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols index 0548f1247f6..daa49cfe152 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols @@ -1,33 +1,32 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5iterable.ts === - interface ISomething { >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) foo: string, ->foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 1, 22)) +>foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 22)) bar: string ->bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 2, 16)) +>bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 1, 16)) } function foo({}, {foo, bar}: ISomething) {} ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 4, 1)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 22)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 3, 1)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 5, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 5, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) function baz([], {foo, bar}: ISomething) {} ->baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 43)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 22)) +>baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5iterable.ts, 5, 43)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 7, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 7, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) function one([], {}) {} ->one : Symbol(one, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 43)) +>one : Symbol(one, Decl(destructuringParameterDeclaration7ES5iterable.ts, 7, 43)) function two([], [a, b, c]: number[]) {} ->two : Symbol(two, Decl(destructuringParameterDeclaration7ES5iterable.ts, 10, 23)) ->a : Symbol(a, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 18)) ->b : Symbol(b, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 20)) ->c : Symbol(c, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 23)) +>two : Symbol(two, Decl(destructuringParameterDeclaration7ES5iterable.ts, 9, 23)) +>a : Symbol(a, Decl(destructuringParameterDeclaration7ES5iterable.ts, 11, 18)) +>b : Symbol(b, Decl(destructuringParameterDeclaration7ES5iterable.ts, 11, 20)) +>c : Symbol(c, Decl(destructuringParameterDeclaration7ES5iterable.ts, 11, 23)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types index 402ea7ac5e1..542407cabe2 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5iterable.ts === - interface ISomething { >ISomething : ISomething diff --git a/tests/baselines/reference/destructuringParameterProperties4.errors.txt b/tests/baselines/reference/destructuringParameterProperties4.errors.txt index 249cecbc74f..6e995baa996 100644 --- a/tests/baselines/reference/destructuringParameterProperties4.errors.txt +++ b/tests/baselines/reference/destructuringParameterProperties4.errors.txt @@ -1,17 +1,16 @@ -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,31): error TS1187: A parameter property may not be declared using a binding pattern. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,59): error TS2339: Property 'b' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,83): error TS2339: Property 'c' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(5,18): error TS2339: Property 'a' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(10,21): error TS2339: Property 'a' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(14,21): error TS2339: Property 'b' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(18,21): error TS2339: Property 'c' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,24): error TS2339: Property 'a' does not exist on type 'C2'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,34): error TS2339: Property 'b' does not exist on type 'C2'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,44): error TS2339: Property 'c' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(2,31): error TS1187: A parameter property may not be declared using a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,59): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,83): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,18): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(9,21): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(13,21): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(17,21): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(23,24): error TS2339: Property 'a' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(23,34): error TS2339: Property 'b' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(23,44): error TS2339: Property 'c' does not exist on type 'C2'. ==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts (10 errors) ==== - class C1 { constructor(private k: T, protected [a, b, c]: [T,U,V]) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/destructuringParameterProperties4.js b/tests/baselines/reference/destructuringParameterProperties4.js index aa8087cfde6..33c906f51b5 100644 --- a/tests/baselines/reference/destructuringParameterProperties4.js +++ b/tests/baselines/reference/destructuringParameterProperties4.js @@ -1,5 +1,4 @@ //// [destructuringParameterProperties4.ts] - class C1 { constructor(private k: T, protected [a, b, c]: [T,U,V]) { if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { diff --git a/tests/baselines/reference/discriminantPropertyCheck.errors.txt b/tests/baselines/reference/discriminantPropertyCheck.errors.txt index 41593c4b224..33bdb6ea731 100644 --- a/tests/baselines/reference/discriminantPropertyCheck.errors.txt +++ b/tests/baselines/reference/discriminantPropertyCheck.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/discriminantPropertyCheck.ts(30,9): error TS2532: Object is possibly 'undefined'. -tests/cases/compiler/discriminantPropertyCheck.ts(66,9): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/discriminantPropertyCheck.ts(29,9): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/discriminantPropertyCheck.ts(65,9): error TS2532: Object is possibly 'undefined'. ==== tests/cases/compiler/discriminantPropertyCheck.ts (2 errors) ==== - type Item = Item1 | Item2; interface Base { diff --git a/tests/baselines/reference/discriminantPropertyCheck.js b/tests/baselines/reference/discriminantPropertyCheck.js index b75a6277735..b946fe52049 100644 --- a/tests/baselines/reference/discriminantPropertyCheck.js +++ b/tests/baselines/reference/discriminantPropertyCheck.js @@ -1,5 +1,4 @@ //// [discriminantPropertyCheck.ts] - type Item = Item1 | Item2; interface Base { diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.js b/tests/baselines/reference/discriminantsAndNullOrUndefined.js index 153950f8ab5..20704edad6c 100644 --- a/tests/baselines/reference/discriminantsAndNullOrUndefined.js +++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.js @@ -1,5 +1,4 @@ //// [discriminantsAndNullOrUndefined.ts] - // Repro from #10228 interface A { kind: 'A'; } diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols b/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols index 3f95fcf3a3f..01fd35e1a74 100644 --- a/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols +++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols @@ -1,61 +1,60 @@ === tests/cases/compiler/discriminantsAndNullOrUndefined.ts === - // Repro from #10228 interface A { kind: 'A'; } >A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0)) ->kind : Symbol(A.kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) +>kind : Symbol(A.kind, Decl(discriminantsAndNullOrUndefined.ts, 2, 13)) interface B { kind: 'B'; } ->B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) ->kind : Symbol(B.kind, Decl(discriminantsAndNullOrUndefined.ts, 4, 13)) +>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 2, 26)) +>kind : Symbol(B.kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) type C = A | B | undefined; ->C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 4, 26)) +>C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) >A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0)) ->B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) +>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 2, 26)) function never(_: never): never { ->never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 6, 27)) ->_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 8, 15)) +>never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 5, 27)) +>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 7, 15)) throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function useA(_: A): void { } ->useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 10, 1)) ->_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 12, 14)) +>useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 9, 1)) +>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 11, 14)) >A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0)) function useB(_: B): void { } ->useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 12, 29)) ->_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 13, 14)) ->B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) +>useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 11, 29)) +>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 12, 14)) +>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 2, 26)) declare var c: C; ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) ->C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 4, 26)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) +>C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) if (c !== undefined) { ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) >undefined : Symbol(undefined) switch (c.kind) { ->c.kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13), Decl(discriminantsAndNullOrUndefined.ts, 4, 13)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) ->kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13), Decl(discriminantsAndNullOrUndefined.ts, 4, 13)) +>c.kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 2, 13), Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) +>kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 2, 13), Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) case 'A': useA(c); break; ->useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 10, 1)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 9, 1)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) case 'B': useB(c); break; ->useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 12, 29)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 11, 29)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) default: never(c); ->never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 6, 27)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 5, 27)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) } } diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.types b/tests/baselines/reference/discriminantsAndNullOrUndefined.types index 7a2918ab83b..fbcdc488333 100644 --- a/tests/baselines/reference/discriminantsAndNullOrUndefined.types +++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.types @@ -1,5 +1,4 @@ === tests/cases/compiler/discriminantsAndNullOrUndefined.ts === - // Repro from #10228 interface A { kind: 'A'; } diff --git a/tests/baselines/reference/discriminantsAndPrimitives.js b/tests/baselines/reference/discriminantsAndPrimitives.js index 1d11781a707..d72ac0ff9f9 100644 --- a/tests/baselines/reference/discriminantsAndPrimitives.js +++ b/tests/baselines/reference/discriminantsAndPrimitives.js @@ -1,5 +1,4 @@ //// [discriminantsAndPrimitives.ts] - // Repro from #10257 plus other tests interface Foo { diff --git a/tests/baselines/reference/discriminantsAndPrimitives.symbols b/tests/baselines/reference/discriminantsAndPrimitives.symbols index c84f32cd990..818fbc663ff 100644 --- a/tests/baselines/reference/discriminantsAndPrimitives.symbols +++ b/tests/baselines/reference/discriminantsAndPrimitives.symbols @@ -1,117 +1,116 @@ === tests/cases/compiler/discriminantsAndPrimitives.ts === - // Repro from #10257 plus other tests interface Foo { >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) kind: "foo"; ->kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 3, 15)) +>kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 2, 15)) name: string; ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } interface Bar { ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) kind: "bar"; ->kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 8, 15)) +>kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 7, 15)) length: string; ->length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 9, 16)) +>length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 8, 16)) } function f1(x: Foo | Bar | string) { ->f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 11, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) +>f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 10, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (typeof x !== 'string') { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } function f2(x: Foo | Bar | string | undefined) { ->f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 20, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) +>f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 19, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (typeof x === "object") { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } function f3(x: Foo | Bar | string | null) { ->f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 29, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) +>f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 28, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (x && typeof x !== "string") { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } function f4(x: Foo | Bar | string | number | null) { ->f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 38, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) +>f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 37, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (x && typeof x === "object") { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } diff --git a/tests/baselines/reference/discriminantsAndPrimitives.types b/tests/baselines/reference/discriminantsAndPrimitives.types index 0870d17948f..a4efa401987 100644 --- a/tests/baselines/reference/discriminantsAndPrimitives.types +++ b/tests/baselines/reference/discriminantsAndPrimitives.types @@ -1,5 +1,4 @@ === tests/cases/compiler/discriminantsAndPrimitives.ts === - // Repro from #10257 plus other tests interface Foo { diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js index cddfb7aecdc..a18eac74cdb 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js @@ -1,5 +1,4 @@ //// [file1.ts] - class C { /*! remove pinned comment anywhere else */ public foo(x: string, y: any) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols index bd6f35e406f..cdf2719546e 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols @@ -1,24 +1,23 @@ === tests/cases/compiler/file1.ts === - class C { >C : Symbol(C, Decl(file1.ts, 0, 0)) /*! remove pinned comment anywhere else */ public foo(x: string, y: any) ->foo : Symbol(C.foo, Decl(file1.ts, 1, 9), Decl(file1.ts, 3, 33)) ->x : Symbol(x, Decl(file1.ts, 3, 15)) ->y : Symbol(y, Decl(file1.ts, 3, 25)) +>foo : Symbol(C.foo, Decl(file1.ts, 0, 9), Decl(file1.ts, 2, 33)) +>x : Symbol(x, Decl(file1.ts, 2, 15)) +>y : Symbol(y, Decl(file1.ts, 2, 25)) public foo(x: string, y: number) { } ->foo : Symbol(C.foo, Decl(file1.ts, 1, 9), Decl(file1.ts, 3, 33)) ->x : Symbol(x, Decl(file1.ts, 4, 15)) ->y : Symbol(y, Decl(file1.ts, 4, 25)) +>foo : Symbol(C.foo, Decl(file1.ts, 0, 9), Decl(file1.ts, 2, 33)) +>x : Symbol(x, Decl(file1.ts, 3, 15)) +>y : Symbol(y, Decl(file1.ts, 3, 25)) } var x = 10; ->x : Symbol(x, Decl(file1.ts, 7, 3)) +>x : Symbol(x, Decl(file1.ts, 6, 3)) /*! remove pinned comment anywhere else */ declare var OData: any; ->OData : Symbol(OData, Decl(file1.ts, 10, 11)) +>OData : Symbol(OData, Decl(file1.ts, 9, 11)) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types index 491ccdbd0d0..8da544663af 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - class C { >C : C diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js index 3198699405d..a93a9911c4d 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js @@ -1,5 +1,4 @@ //// [doNotEmitPinnedCommentOnNotEmittedNodets.ts] - class C { /*! remove pinned comment anywhere else */ public foo(x: string, y: any) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols index 7b96fc028b1..0e3cdc1eb9f 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/doNotEmitPinnedCommentOnNotEmittedNodets.ts === - class C { >C : Symbol(C, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 0, 0)) /*! remove pinned comment anywhere else */ public foo(x: string, y: any) ->foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 1, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 33)) ->x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 15)) ->y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 25)) +>foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 0, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 33)) +>x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 15)) +>y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 25)) public foo(x: string, y: number) { } ->foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 1, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 33)) ->x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 4, 15)) ->y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 4, 25)) +>foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 0, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 33)) +>x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 15)) +>y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 25)) } /*! remove pinned comment anywhere else */ declare var OData: any; ->OData : Symbol(OData, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 8, 11)) +>OData : Symbol(OData, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 7, 11)) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types index 4369af63f53..32391644dcd 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types @@ -1,5 +1,4 @@ === tests/cases/compiler/doNotEmitPinnedCommentOnNotEmittedNodets.ts === - class C { >C : C diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js index f3b0888a78f..eaa9cd06514 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/doNotEmitTripleSlashCommentsInEmptyFile.ts] //// //// [file0.ts] - //// [file1.ts] diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols index d18810db280..5e3ebab68db 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols @@ -4,7 +4,6 @@ No type information for this code./// No type information for this code./// No type information for this code.=== tests/cases/compiler/file0.ts === -No type information for this code. No type information for this code.=== tests/cases/compiler/file1.ts === No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types index d18810db280..5e3ebab68db 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types @@ -4,7 +4,6 @@ No type information for this code./// No type information for this code./// No type information for this code.=== tests/cases/compiler/file0.ts === -No type information for this code. No type information for this code.=== tests/cases/compiler/file1.ts === No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js index 9067b5b80a9..57727cfd187 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/doNotEmitTripleSlashCommentsOnNotEmittedNode.ts] //// //// [file0.ts] - /// declare var OData: any; diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols index bb920d2ee1c..c4005efd090 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols @@ -5,8 +5,7 @@ interface F { } === tests/cases/compiler/file0.ts === - /// declare var OData: any; ->OData : Symbol(OData, Decl(file0.ts, 2, 11)) +>OData : Symbol(OData, Decl(file0.ts, 1, 11)) diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types index 59b63ea1a2f..cdaa7ba4368 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types @@ -5,7 +5,6 @@ interface F { } === tests/cases/compiler/file0.ts === - /// declare var OData: any; >OData : any diff --git a/tests/baselines/reference/doNotemitTripleSlashComments.js b/tests/baselines/reference/doNotemitTripleSlashComments.js index fe17db54cb1..f3f74401902 100644 --- a/tests/baselines/reference/doNotemitTripleSlashComments.js +++ b/tests/baselines/reference/doNotemitTripleSlashComments.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/doNotemitTripleSlashComments.ts] //// //// [file0.ts] - /// /// /// diff --git a/tests/baselines/reference/doNotemitTripleSlashComments.symbols b/tests/baselines/reference/doNotemitTripleSlashComments.symbols index 36b31842f8b..0b8884b8c21 100644 --- a/tests/baselines/reference/doNotemitTripleSlashComments.symbols +++ b/tests/baselines/reference/doNotemitTripleSlashComments.symbols @@ -11,16 +11,15 @@ function bar() { } === tests/cases/compiler/file0.ts === - /// /// /// var x = 10; ->x : Symbol(x, Decl(file0.ts, 4, 3)) +>x : Symbol(x, Decl(file0.ts, 3, 3)) /// var y = "hello"; ->y : Symbol(y, Decl(file0.ts, 7, 3)) +>y : Symbol(y, Decl(file0.ts, 6, 3)) /// diff --git a/tests/baselines/reference/doNotemitTripleSlashComments.types b/tests/baselines/reference/doNotemitTripleSlashComments.types index 8bad6e601de..09553ac9295 100644 --- a/tests/baselines/reference/doNotemitTripleSlashComments.types +++ b/tests/baselines/reference/doNotemitTripleSlashComments.types @@ -11,7 +11,6 @@ function bar() { } === tests/cases/compiler/file0.ts === - /// /// /// diff --git a/tests/baselines/reference/doWhileBreakStatements.js b/tests/baselines/reference/doWhileBreakStatements.js index 8e272ceed0a..a2bc0d3c549 100644 --- a/tests/baselines/reference/doWhileBreakStatements.js +++ b/tests/baselines/reference/doWhileBreakStatements.js @@ -1,5 +1,4 @@ //// [doWhileBreakStatements.ts] - do { break; } while(true) diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols index 14db540598d..7d9db9a5ebb 100644 --- a/tests/baselines/reference/doWhileBreakStatements.symbols +++ b/tests/baselines/reference/doWhileBreakStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts === - do { break; } while(true) @@ -35,7 +34,7 @@ do do do break SEVEN; while (true) while (true) while (true) EIGHT: do{ var fn = function () { } ->fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 35, 7)) +>fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 34, 7)) break EIGHT; }while(true) diff --git a/tests/baselines/reference/doWhileBreakStatements.types b/tests/baselines/reference/doWhileBreakStatements.types index bc5102dc330..09f7794310f 100644 --- a/tests/baselines/reference/doWhileBreakStatements.types +++ b/tests/baselines/reference/doWhileBreakStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts === - do { break; } while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.js b/tests/baselines/reference/doWhileContinueStatements.js index 51bac3c4e09..7f73157fd99 100644 --- a/tests/baselines/reference/doWhileContinueStatements.js +++ b/tests/baselines/reference/doWhileContinueStatements.js @@ -1,5 +1,4 @@ //// [doWhileContinueStatements.ts] - do { continue; } while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols index 36ca2dde764..e4c6d577d5a 100644 --- a/tests/baselines/reference/doWhileContinueStatements.symbols +++ b/tests/baselines/reference/doWhileContinueStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts === - do { continue; } while(true) @@ -35,7 +34,7 @@ do do do continue SEVEN; while (true) while (true) while (true) EIGHT: do{ var fn = function () { } ->fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 35, 7)) +>fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 34, 7)) continue EIGHT; }while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.types b/tests/baselines/reference/doWhileContinueStatements.types index 66ff052a3cd..c0cd272afcd 100644 --- a/tests/baselines/reference/doWhileContinueStatements.types +++ b/tests/baselines/reference/doWhileContinueStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts === - do { continue; } while(true) diff --git a/tests/baselines/reference/downlevelLetConst12.errors.txt b/tests/baselines/reference/downlevelLetConst12.errors.txt index 0af224b017e..7d5c6828207 100644 --- a/tests/baselines/reference/downlevelLetConst12.errors.txt +++ b/tests/baselines/reference/downlevelLetConst12.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/downlevelLetConst12.ts(7,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst12.ts(10,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst12.ts(6,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst12.ts(9,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ==== tests/cases/compiler/downlevelLetConst12.ts (2 errors) ==== - 'use strict' // top level let\const should not be renamed let foo; diff --git a/tests/baselines/reference/downlevelLetConst12.js b/tests/baselines/reference/downlevelLetConst12.js index bd0ab2fb46f..bdc33aaba9d 100644 --- a/tests/baselines/reference/downlevelLetConst12.js +++ b/tests/baselines/reference/downlevelLetConst12.js @@ -1,5 +1,4 @@ //// [downlevelLetConst12.ts] - 'use strict' // top level let\const should not be renamed let foo; diff --git a/tests/baselines/reference/downlevelLetConst13.js b/tests/baselines/reference/downlevelLetConst13.js index 324c0cd9293..251468519ad 100644 --- a/tests/baselines/reference/downlevelLetConst13.js +++ b/tests/baselines/reference/downlevelLetConst13.js @@ -1,5 +1,4 @@ //// [downlevelLetConst13.ts] - 'use strict' // exported let\const bindings should not be renamed diff --git a/tests/baselines/reference/downlevelLetConst13.symbols b/tests/baselines/reference/downlevelLetConst13.symbols index f8cd2e548a9..b4c3ce743f3 100644 --- a/tests/baselines/reference/downlevelLetConst13.symbols +++ b/tests/baselines/reference/downlevelLetConst13.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/downlevelLetConst13.ts === - 'use strict' // exported let\const bindings should not be renamed export let foo = 10; ->foo : Symbol(foo, Decl(downlevelLetConst13.ts, 4, 10)) +>foo : Symbol(foo, Decl(downlevelLetConst13.ts, 3, 10)) export const bar = "123" ->bar : Symbol(bar, Decl(downlevelLetConst13.ts, 5, 12)) +>bar : Symbol(bar, Decl(downlevelLetConst13.ts, 4, 12)) export let [bar1] = [1]; ->bar1 : Symbol(bar1, Decl(downlevelLetConst13.ts, 6, 12)) +>bar1 : Symbol(bar1, Decl(downlevelLetConst13.ts, 5, 12)) export const [bar2] = [2]; ->bar2 : Symbol(bar2, Decl(downlevelLetConst13.ts, 7, 14)) +>bar2 : Symbol(bar2, Decl(downlevelLetConst13.ts, 6, 14)) export let {a: bar3} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 24)) ->bar3 : Symbol(bar3, Decl(downlevelLetConst13.ts, 8, 12)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 24)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 7, 24)) +>bar3 : Symbol(bar3, Decl(downlevelLetConst13.ts, 7, 12)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 7, 24)) export const {a: bar4} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 9, 26)) ->bar4 : Symbol(bar4, Decl(downlevelLetConst13.ts, 9, 14)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 9, 26)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 26)) +>bar4 : Symbol(bar4, Decl(downlevelLetConst13.ts, 8, 14)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 26)) export module M { ->M : Symbol(M, Decl(downlevelLetConst13.ts, 9, 34)) +>M : Symbol(M, Decl(downlevelLetConst13.ts, 8, 34)) export let baz = 100; ->baz : Symbol(baz, Decl(downlevelLetConst13.ts, 12, 14)) +>baz : Symbol(baz, Decl(downlevelLetConst13.ts, 11, 14)) export const baz2 = true; ->baz2 : Symbol(baz2, Decl(downlevelLetConst13.ts, 13, 16)) +>baz2 : Symbol(baz2, Decl(downlevelLetConst13.ts, 12, 16)) export let [bar5] = [1]; ->bar5 : Symbol(bar5, Decl(downlevelLetConst13.ts, 14, 16)) +>bar5 : Symbol(bar5, Decl(downlevelLetConst13.ts, 13, 16)) export const [bar6] = [2]; ->bar6 : Symbol(bar6, Decl(downlevelLetConst13.ts, 15, 18)) +>bar6 : Symbol(bar6, Decl(downlevelLetConst13.ts, 14, 18)) export let {a: bar7} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 28)) ->bar7 : Symbol(bar7, Decl(downlevelLetConst13.ts, 16, 16)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 28)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 15, 28)) +>bar7 : Symbol(bar7, Decl(downlevelLetConst13.ts, 15, 16)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 15, 28)) export const {a: bar8} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 17, 30)) ->bar8 : Symbol(bar8, Decl(downlevelLetConst13.ts, 17, 18)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 17, 30)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 30)) +>bar8 : Symbol(bar8, Decl(downlevelLetConst13.ts, 16, 18)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 30)) } diff --git a/tests/baselines/reference/downlevelLetConst13.types b/tests/baselines/reference/downlevelLetConst13.types index 92bb3226f94..47307d504e5 100644 --- a/tests/baselines/reference/downlevelLetConst13.types +++ b/tests/baselines/reference/downlevelLetConst13.types @@ -1,5 +1,4 @@ === tests/cases/compiler/downlevelLetConst13.ts === - 'use strict' >'use strict' : "use strict" diff --git a/tests/baselines/reference/downlevelLetConst16.errors.txt b/tests/baselines/reference/downlevelLetConst16.errors.txt index a6ada633016..905d1a607e8 100644 --- a/tests/baselines/reference/downlevelLetConst16.errors.txt +++ b/tests/baselines/reference/downlevelLetConst16.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/downlevelLetConst16.ts(152,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst16.ts(165,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst16.ts(196,14): error TS2461: Type 'undefined' is not an array type. -tests/cases/compiler/downlevelLetConst16.ts(203,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature. -tests/cases/compiler/downlevelLetConst16.ts(217,16): error TS2461: Type 'undefined' is not an array type. -tests/cases/compiler/downlevelLetConst16.ts(224,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature. +tests/cases/compiler/downlevelLetConst16.ts(151,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst16.ts(164,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst16.ts(195,14): error TS2461: Type 'undefined' is not an array type. +tests/cases/compiler/downlevelLetConst16.ts(202,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature. +tests/cases/compiler/downlevelLetConst16.ts(216,16): error TS2461: Type 'undefined' is not an array type. +tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature. ==== tests/cases/compiler/downlevelLetConst16.ts (6 errors) ==== - 'use strict' declare function use(a: any); diff --git a/tests/baselines/reference/downlevelLetConst16.js b/tests/baselines/reference/downlevelLetConst16.js index edc778209be..944bb192e90 100644 --- a/tests/baselines/reference/downlevelLetConst16.js +++ b/tests/baselines/reference/downlevelLetConst16.js @@ -1,5 +1,4 @@ //// [downlevelLetConst16.ts] - 'use strict' declare function use(a: any); diff --git a/tests/baselines/reference/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt index 5b91498f173..3c3ae0e01e9 100644 --- a/tests/baselines/reference/downlevelLetConst18.errors.txt +++ b/tests/baselines/reference/downlevelLetConst18.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/downlevelLetConst18.ts(5,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. -tests/cases/compiler/downlevelLetConst18.ts(9,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. +tests/cases/compiler/downlevelLetConst18.ts(4,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. +tests/cases/compiler/downlevelLetConst18.ts(8,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. ==== tests/cases/compiler/downlevelLetConst18.ts (2 errors) ==== - 'use strict' for (let x; ;) { diff --git a/tests/baselines/reference/downlevelLetConst18.js b/tests/baselines/reference/downlevelLetConst18.js index 7dcd563f759..9827efdbc95 100644 --- a/tests/baselines/reference/downlevelLetConst18.js +++ b/tests/baselines/reference/downlevelLetConst18.js @@ -1,5 +1,4 @@ //// [downlevelLetConst18.ts] - 'use strict' for (let x; ;) { diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt index d210588234d..94c5a9a8e38 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt @@ -1,28 +1,27 @@ -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,17): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,21): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,27): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,14): error TS2300: Duplicate identifier 'a'. tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,21): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,27): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,14): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,14): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,19): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,14): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,17): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,22): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,14): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,20): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,14): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,21): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,27): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,34): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,39): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,48): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(8,14): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(8,20): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,14): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,19): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,14): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,17): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,22): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,14): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,20): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,14): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,21): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,27): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,34): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,39): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,48): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,14): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,20): error TS2300: Duplicate identifier 'f'. ==== tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts (21 errors) ==== - function f0(a, [a, [b]], {b}) { } ~ !!! error TS2300: Duplicate identifier 'a'. diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js index 0c1eb5f3210..639f4df7880 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js @@ -1,5 +1,4 @@ //// [duplicateIdentifierBindingElementInParameterDeclaration1.ts] - function f0(a, [a, [b]], {b}) { } function f1([a, a]) { } function f2({b}, {b}) { } diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt index e3d1dc621f8..00720540de7 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt @@ -1,28 +1,27 @@ -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,17): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,21): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,27): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,14): error TS2300: Duplicate identifier 'a'. tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,21): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,27): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,14): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,14): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,19): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,14): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,18): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,24): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,14): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,21): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,14): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,21): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,27): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,35): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,40): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,49): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(9,14): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(9,20): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,14): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,19): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,14): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,18): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,24): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,14): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,21): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,14): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,21): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,27): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,35): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,40): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,49): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,14): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,20): error TS2300: Duplicate identifier 'f'. ==== tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts (21 errors) ==== - "use strict" function f0(a, [a, [b]], {b}) { } ~ diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js index e423b035d9d..caaf482d269 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js @@ -1,5 +1,4 @@ //// [duplicateIdentifierBindingElementInParameterDeclaration2.ts] - "use strict" function f0(a, [a, [b]], {b}) { } function f1([a, a]) { } diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt index 7ef43dc6470..400bafa3c1a 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -1,6 +1,6 @@ -tests/cases/compiler/file1.ts(4,7): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/file1.ts(5,10): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/file1.ts(9,12): error TS2300: Duplicate identifier 'x'. +tests/cases/compiler/file1.ts(3,7): error TS2300: Duplicate identifier 'C2'. +tests/cases/compiler/file1.ts(4,10): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/file1.ts(8,12): error TS2300: Duplicate identifier 'x'. tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file2.ts(4,7): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file2.ts(7,8): error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged. @@ -8,7 +8,6 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. ==== tests/cases/compiler/file1.ts (3 errors) ==== - interface I { } class C1 { } class C2 { } diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js index 70635dcbd7e..eb1eeb9b302 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts] //// //// [file1.ts] - interface I { } class C1 { } class C2 { } diff --git a/tests/baselines/reference/duplicateLabel1.errors.txt b/tests/baselines/reference/duplicateLabel1.errors.txt index 03d4e999597..5f52933e1d6 100644 --- a/tests/baselines/reference/duplicateLabel1.errors.txt +++ b/tests/baselines/reference/duplicateLabel1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/duplicateLabel1.ts(3,1): error TS1114: Duplicate label 'target'. +tests/cases/compiler/duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target'. ==== tests/cases/compiler/duplicateLabel1.ts (1 errors) ==== - target: target: ~~~~~~ diff --git a/tests/baselines/reference/duplicateLabel1.js b/tests/baselines/reference/duplicateLabel1.js index 5251cec3e36..e7976895c94 100644 --- a/tests/baselines/reference/duplicateLabel1.js +++ b/tests/baselines/reference/duplicateLabel1.js @@ -1,5 +1,4 @@ //// [duplicateLabel1.ts] - target: target: while (true) { diff --git a/tests/baselines/reference/duplicateLabel2.errors.txt b/tests/baselines/reference/duplicateLabel2.errors.txt index d178a8ffe5c..bc64c9c323b 100644 --- a/tests/baselines/reference/duplicateLabel2.errors.txt +++ b/tests/baselines/reference/duplicateLabel2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/duplicateLabel2.ts(4,3): error TS1114: Duplicate label 'target'. +tests/cases/compiler/duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target'. ==== tests/cases/compiler/duplicateLabel2.ts (1 errors) ==== - target: while (true) { target: diff --git a/tests/baselines/reference/duplicateLabel2.js b/tests/baselines/reference/duplicateLabel2.js index 40a5ee4595e..9ee9671d59d 100644 --- a/tests/baselines/reference/duplicateLabel2.js +++ b/tests/baselines/reference/duplicateLabel2.js @@ -1,5 +1,4 @@ //// [duplicateLabel2.ts] - target: while (true) { target: diff --git a/tests/baselines/reference/duplicateLabel3.js b/tests/baselines/reference/duplicateLabel3.js index a1d33e46fc1..37e9619e8f6 100644 --- a/tests/baselines/reference/duplicateLabel3.js +++ b/tests/baselines/reference/duplicateLabel3.js @@ -1,5 +1,4 @@ //// [duplicateLabel3.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/duplicateLabel3.symbols b/tests/baselines/reference/duplicateLabel3.symbols index 89f2d5ee48a..07d0ded2923 100644 --- a/tests/baselines/reference/duplicateLabel3.symbols +++ b/tests/baselines/reference/duplicateLabel3.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/duplicateLabel3.ts === - target: while (true) { function f() { ->f : Symbol(f, Decl(duplicateLabel3.ts, 2, 14)) +>f : Symbol(f, Decl(duplicateLabel3.ts, 1, 14)) target: while (true) { diff --git a/tests/baselines/reference/duplicateLabel3.types b/tests/baselines/reference/duplicateLabel3.types index 56af6f24088..bc82f795811 100644 --- a/tests/baselines/reference/duplicateLabel3.types +++ b/tests/baselines/reference/duplicateLabel3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/duplicateLabel3.ts === - target: >target : any diff --git a/tests/baselines/reference/duplicateLabel4.js b/tests/baselines/reference/duplicateLabel4.js index d5b81b1e5bb..22d072d38d7 100644 --- a/tests/baselines/reference/duplicateLabel4.js +++ b/tests/baselines/reference/duplicateLabel4.js @@ -1,5 +1,4 @@ //// [duplicateLabel4.ts] - target: while (true) { } diff --git a/tests/baselines/reference/duplicateLabel4.symbols b/tests/baselines/reference/duplicateLabel4.symbols index 5660782e2ec..c671abcef35 100644 --- a/tests/baselines/reference/duplicateLabel4.symbols +++ b/tests/baselines/reference/duplicateLabel4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/duplicateLabel4.ts === - -No type information for this code.target: +target: No type information for this code.while (true) { No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/duplicateLabel4.types b/tests/baselines/reference/duplicateLabel4.types index 2f5890ae9a4..db82656f84e 100644 --- a/tests/baselines/reference/duplicateLabel4.types +++ b/tests/baselines/reference/duplicateLabel4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/duplicateLabel4.ts === - target: >target : any diff --git a/tests/baselines/reference/duplicateLocalVariable1.errors.txt b/tests/baselines/reference/duplicateLocalVariable1.errors.txt index b264574ea09..0486cd1af60 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.errors.txt +++ b/tests/baselines/reference/duplicateLocalVariable1.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/duplicateLocalVariable1.ts(2,4): error TS1005: ';' expected. -tests/cases/compiler/duplicateLocalVariable1.ts(2,11): error TS1146: Declaration expected. -tests/cases/compiler/duplicateLocalVariable1.ts(2,13): error TS2304: Cannot find name 'commonjs'. -tests/cases/compiler/duplicateLocalVariable1.ts(187,22): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'string', but here has type 'number'. -tests/cases/compiler/duplicateLocalVariable1.ts(187,29): error TS2365: Operator '<' cannot be applied to types 'string' and 'number'. -tests/cases/compiler/duplicateLocalVariable1.ts(187,37): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/compiler/duplicateLocalVariable1.ts(1,4): error TS1005: ';' expected. +tests/cases/compiler/duplicateLocalVariable1.ts(1,11): error TS1146: Declaration expected. +tests/cases/compiler/duplicateLocalVariable1.ts(1,13): error TS2304: Cannot find name 'commonjs'. +tests/cases/compiler/duplicateLocalVariable1.ts(186,22): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'string', but here has type 'number'. +tests/cases/compiler/duplicateLocalVariable1.ts(186,29): error TS2365: Operator '<' cannot be applied to types 'string' and 'number'. +tests/cases/compiler/duplicateLocalVariable1.ts(186,37): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. ==== tests/cases/compiler/duplicateLocalVariable1.ts (6 errors) ==== - / /@module: commonjs ~ !!! error TS1005: ';' expected. diff --git a/tests/baselines/reference/duplicateLocalVariable1.js b/tests/baselines/reference/duplicateLocalVariable1.js index c1417de9dfe..61e8dcd02f8 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.js +++ b/tests/baselines/reference/duplicateLocalVariable1.js @@ -1,5 +1,4 @@ //// [duplicateLocalVariable1.ts] - / /@module: commonjs //import FileManager = require('filemanager'); diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt index 80b108bbd66..91b808759df 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(2,11): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(2,22): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(1,11): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(1,22): error TS2300: Duplicate identifier 'a'. ==== tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts (2 errors) ==== - let x = <{a: number; a: number}>{}; ~ !!! error TS2300: Duplicate identifier 'a'. diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js index 03f46ad110a..e0b54e62058 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js @@ -1,5 +1,4 @@ //// [duplicatePropertiesInTypeAssertions01.ts] - let x = <{a: number; a: number}>{}; //// [duplicatePropertiesInTypeAssertions01.js] diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt index eeb9ffa9302..a979da4a831 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(2,16): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(2,27): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(1,16): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(1,27): error TS2300: Duplicate identifier 'a'. ==== tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts (2 errors) ==== - let x = {} as {a: number; a: number}; ~ !!! error TS2300: Duplicate identifier 'a'. diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js index 8aa4449595a..8fe55ed046e 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js @@ -1,5 +1,4 @@ //// [duplicatePropertiesInTypeAssertions02.ts] - let x = {} as {a: number; a: number}; //// [duplicatePropertiesInTypeAssertions02.js] diff --git a/tests/baselines/reference/duplicateVariablesByScope.js b/tests/baselines/reference/duplicateVariablesByScope.js index 2f9a0348811..ed6b7834a1d 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.js +++ b/tests/baselines/reference/duplicateVariablesByScope.js @@ -1,5 +1,4 @@ //// [duplicateVariablesByScope.ts] - // duplicate local variables are only reported at global scope module M { diff --git a/tests/baselines/reference/duplicateVariablesByScope.symbols b/tests/baselines/reference/duplicateVariablesByScope.symbols index 88eb44d0181..abc4a9580e4 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.symbols +++ b/tests/baselines/reference/duplicateVariablesByScope.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/duplicateVariablesByScope.ts === - // duplicate local variables are only reported at global scope module M { >M : Symbol(M, Decl(duplicateVariablesByScope.ts, 0, 0)) for (var j = 0; j < 10; j++) { ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) } for (var j = 0; j < 10; j++) { ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) } } function foo() { ->foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 9, 1)) +>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 8, 1)) var x = 2; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7)) var x = 1; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7)) if (true) { var result = 1; ->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11)) +>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11)) } else { var result = 2; ->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11)) +>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11)) } } class C { ->C : Symbol(C, Decl(duplicateVariablesByScope.ts, 20, 1)) +>C : Symbol(C, Decl(duplicateVariablesByScope.ts, 19, 1)) foo() { ->foo : Symbol(C.foo, Decl(duplicateVariablesByScope.ts, 22, 9)) +>foo : Symbol(C.foo, Decl(duplicateVariablesByScope.ts, 21, 9)) try { var x = 1; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15)) } catch (e) { ->e : Symbol(e, Decl(duplicateVariablesByScope.ts, 27, 15)) +>e : Symbol(e, Decl(duplicateVariablesByScope.ts, 26, 15)) var x = 2; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15)) } } } diff --git a/tests/baselines/reference/duplicateVariablesByScope.types b/tests/baselines/reference/duplicateVariablesByScope.types index 4eec3a2054f..6993827d4f8 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.types +++ b/tests/baselines/reference/duplicateVariablesByScope.types @@ -1,5 +1,4 @@ === tests/cases/compiler/duplicateVariablesByScope.ts === - // duplicate local variables are only reported at global scope module M { diff --git a/tests/baselines/reference/dynamicRequire.js b/tests/baselines/reference/dynamicRequire.js index 28b35970601..36737ff7a04 100644 --- a/tests/baselines/reference/dynamicRequire.js +++ b/tests/baselines/reference/dynamicRequire.js @@ -1,5 +1,4 @@ //// [a.js] - function foo(name) { var s = require("t/" + name) } diff --git a/tests/baselines/reference/dynamicRequire.symbols b/tests/baselines/reference/dynamicRequire.symbols index c307d578de7..ba593556f25 100644 --- a/tests/baselines/reference/dynamicRequire.symbols +++ b/tests/baselines/reference/dynamicRequire.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.js === - function foo(name) { >foo : Symbol(foo, Decl(a.js, 0, 0)) ->name : Symbol(name, Decl(a.js, 1, 13)) +>name : Symbol(name, Decl(a.js, 0, 13)) var s = require("t/" + name) ->s : Symbol(s, Decl(a.js, 2, 7)) ->name : Symbol(name, Decl(a.js, 1, 13)) +>s : Symbol(s, Decl(a.js, 1, 7)) +>name : Symbol(name, Decl(a.js, 0, 13)) } diff --git a/tests/baselines/reference/dynamicRequire.types b/tests/baselines/reference/dynamicRequire.types index 9b7a6c359d5..298563f73a2 100644 --- a/tests/baselines/reference/dynamicRequire.types +++ b/tests/baselines/reference/dynamicRequire.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - function foo(name) { >foo : (name: any) => void >name : any diff --git a/tests/baselines/reference/elidingImportNames.js b/tests/baselines/reference/elidingImportNames.js index f878c5044ea..6b1d7968c9b 100644 --- a/tests/baselines/reference/elidingImportNames.js +++ b/tests/baselines/reference/elidingImportNames.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/elidingImportNames.ts] //// //// [elidingImportNames_test.ts] - import a = require('./elidingImportNames_main'); // alias used in typeof var b = a; var x: typeof a; diff --git a/tests/baselines/reference/elidingImportNames.symbols b/tests/baselines/reference/elidingImportNames.symbols index d9cdcd61ffe..1432e500c4d 100644 --- a/tests/baselines/reference/elidingImportNames.symbols +++ b/tests/baselines/reference/elidingImportNames.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/elidingImportNames_test.ts === - import a = require('./elidingImportNames_main'); // alias used in typeof >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0)) var b = a; ->b : Symbol(b, Decl(elidingImportNames_test.ts, 2, 3)) +>b : Symbol(b, Decl(elidingImportNames_test.ts, 1, 3)) >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0)) var x: typeof a; ->x : Symbol(x, Decl(elidingImportNames_test.ts, 3, 3)) +>x : Symbol(x, Decl(elidingImportNames_test.ts, 2, 3)) >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0)) import a2 = require('./elidingImportNames_main1'); // alias not used in typeof ->a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 3, 16)) +>a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 2, 16)) var b2 = a2; ->b2 : Symbol(b2, Decl(elidingImportNames_test.ts, 5, 3)) ->a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 3, 16)) +>b2 : Symbol(b2, Decl(elidingImportNames_test.ts, 4, 3)) +>a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 2, 16)) === tests/cases/compiler/elidingImportNames_main.ts === diff --git a/tests/baselines/reference/elidingImportNames.types b/tests/baselines/reference/elidingImportNames.types index 8dd6b315137..927020b849c 100644 --- a/tests/baselines/reference/elidingImportNames.types +++ b/tests/baselines/reference/elidingImportNames.types @@ -1,5 +1,4 @@ === tests/cases/compiler/elidingImportNames_test.ts === - import a = require('./elidingImportNames_main'); // alias used in typeof >a : typeof a diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt index 55f0ce2230a..29aab1314f8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts(1,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts (1 errors) ==== - var a = () => arguments; ~~~~~~~~~ !!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js index b6774dd5407..15c549ab053 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments02.ts] - var a = () => arguments; //// [emitArrowFunctionWhenUsingArguments02.js] diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js index 0f35b8898b2..1396702ff7e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments02_ES6.ts] - var a = () => arguments; //// [emitArrowFunctionWhenUsingArguments02_ES6.js] diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols index e403a2c3da1..4843562aaec 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts === - var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 0, 3)) >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types index fe5ac353ce6..40859c33cc3 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts === - var a = () => arguments; >a : () => IArguments >() => arguments : () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt index d914e14d93a..3c1bb6b913b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts(3,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts (1 errors) ==== - var arguments; var a = () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js index 5b57f7acf0d..2d8415b856b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments03.ts] - var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js index d4d35e7abdc..fbaf9cea89a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments03_ES6.ts] - var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols index 08bae382794..71518083b1f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts === - var arguments; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 1, 3)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 0, 3)) var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 3)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 1, 3)) >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types index 33a45a39af1..ad46bec71b6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts === - var arguments; >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt index 12e416f893f..62359b15cb5 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts(4,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts (1 errors) ==== - function f() { var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js index 588610a4022..e9a5e15d718 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments04.ts] - function f() { var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js index 63e896039c9..ca95bc230a9 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments04_ES6.ts] - function f() { var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols index 708615a95c6..d42db50fa3b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 0, 0)) var arguments; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 1, 7)) var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 2, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types index 495ca1582e6..e371862ee4d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt index 4256dab30c2..97a34d35522 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts(2,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts (1 errors) ==== - function f(arguments) { var a = () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js index b4ed2b383b7..38379a69cb2 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments05.ts] - function f(arguments) { var a = () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js index 9fe68e9bb48..a6161822cac 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments05_ES6.ts] - function f(arguments) { var a = () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols index 379a5cf92f1..cfa539d1948 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 0, 11)) var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 1, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types index 4e9da2f642b..bcb452f0940 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt index 5b078f22f44..3ee3dbf2755 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts(2,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts (1 errors) ==== - function f(arguments) { var a = () => () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js index d004b77e947..cec5ba87289 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments06.ts] - function f(arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js index 6b83e0c60d9..859567f6d28 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments06_ES6.ts] - function f(arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols index e59f487f864..0aef2f06c45 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 0, 11)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 1, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types index 82571174a1e..f29eb52f32b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt index da1f7dd28f9..983e03876a0 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts(3,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts(2,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts (1 errors) ==== - function f(arguments) { var a = (arguments) => () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js index 7f06036dfc1..836f4f6d75e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments07.ts] - function f(arguments) { var a = (arguments) => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js index bdc8cf82d44..95d92f2c2ff 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments07_ES6.ts] - function f(arguments) { var a = (arguments) => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols index 5de21ffbebd..4fdce2cccb1 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 0, 11)) var a = (arguments) => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 13)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 13)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types index 967631cc57b..168ffac3c5e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js index dbb89d4eb6b..130b8788fd6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments08.ts] - function f(arguments) { var a = () => (arguments) => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols index 80f7f507978..a3a4c19db72 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments08.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 0, 11)) var a = () => (arguments) => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 19)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 19)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types index 4b6d1e19b4a..a6653e510ee 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js index ee568185c0a..bb82cd9b369 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments08_ES6.ts] - function f(arguments) { var a = () => (arguments) => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols index bfbb055cc32..f328046d934 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 0, 11)) var a = () => (arguments) => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 19)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 19)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types index ffa0f7f0bca..532508c93db 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt index 72239150cf3..8c2473128e5 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts(2,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts (1 errors) ==== - function f(_arguments) { var a = () => () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js index c879e6f1ce9..764a5426377 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments09.ts] - function f(_arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js index 15932510d39..4b27e13649e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments09_ES6.ts] - function f(_arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols index ff8f114c052..12ba6119b5e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts === - function f(_arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 0, 0)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 1, 11)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 0, 11)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 1, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types index 77f44eebfca..bb867e477b0 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts === - function f(_arguments) { >f : (_arguments: any) => void >_arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt index 254ad2cbc4d..39d451d1da4 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts (1 errors) ==== - function f() { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js index a0da99f796c..ca1252825af 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments10.ts] - function f() { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js index 83d2b735829..33c2cb85410 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments10_ES6.ts] - function f() { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols index 1d9965fa6ad..ca1cdebf8ad 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 0, 0)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 1, 7)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 2, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types index cca81995253..83bd03cc077 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt index 0606a7784b3..c38c10e2b24 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts (1 errors) ==== - function f(arguments) { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js index 13c1c771c34..93a808f5775 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments11.ts] - function f(arguments) { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js index 9616d2d351c..bf67e5e3c8f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments11_ES6.ts] - function f(arguments) { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols index a8f9c86c1b2..1af084727be 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 0, 11)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 1, 7)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 2, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types index 5dddd8fba7a..fa19fe7b9b1 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt index 4b2dd76a5d0..6a8433097b2 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(3,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(4,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(2,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(3,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts (2 errors) ==== - class C { f(arguments) { ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js index a2c0b7df488..5ee07246347 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments12.ts] - class C { f(arguments) { var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt index 8a3018ceb9c..c9a21cdb43c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts(3,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts(2,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts (1 errors) ==== - class C { f(arguments) { ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js index 8e7631f6fed..566ffa19922 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments12_ES6.ts] - class C { f(arguments) { var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js index ead0a96dacd..af0cff55d98 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments13.ts] - function f() { var _arguments = 10; var a = (arguments) => () => _arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols index b46d8ab1a63..2db823728f8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments13.ts, 0, 0)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 1, 7)) var a = (arguments) => () => _arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 13)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 13)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 1, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types index 82a027d2dc8..d9bb22d7945 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js index 818d27a1f57..5bbe50d44c8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments13_ES6.ts] - function f() { var _arguments = 10; var a = (arguments) => () => _arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols index 5c4ec4cb687..11fbf090e4b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 0, 0)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 1, 7)) var a = (arguments) => () => _arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 13)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 13)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 1, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types index 59b39a444e1..102ddc0dfaa 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt index 8e38cb9d4d3..c00b8acb82a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts (1 errors) ==== - function f() { if (Math.random()) { const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js index bd94a2fda9c..92987b57719 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments14.ts] - function f() { if (Math.random()) { const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js index cea4589debb..0c3b7f4245b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments14_ES6.ts] - function f() { if (Math.random()) { let arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols index fe6788b31f5..af88159a9a4 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 0, 0)) @@ -9,7 +8,7 @@ function f() { >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) let arguments = 100; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 2, 11)) return () => arguments; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types index df47ed17890..19526febab3 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts === - function f() { >f : () => () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt index 02fb22861c5..bbf81e6edfe 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts(6,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts (1 errors) ==== - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js index bc5f7dca7ee..a7ece8d0b90 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments15.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js index 0fa3c9d5f64..50dc52b006a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments15_ES6.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols index 63ee68f0aa7..b87f113f7b2 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 0, 0)) var arguments = "hello"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 1, 7)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) @@ -12,7 +11,7 @@ function f() { >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) const arguments = 100; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 3, 13)) return () => arguments; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types index 558aada2826..69b1e795071 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts === - function f() { >f : () => () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt index 4480e0f570a..82fa304b734 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts (1 errors) ==== - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js index 0a87a3c6ac2..d14304c5e9d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments16.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js index b9aaf7240a7..316a509d2ba 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments16_ES6.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols index 6ea3019f1e6..3cc31438f74 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 0, 0)) var arguments = "hello"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 5, 7)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) @@ -15,5 +14,5 @@ function f() { >arguments : Symbol(arguments) } var arguments = "world"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 5, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types index bedbe3dc8b6..50c619035ac 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts === - function f() { >f : () => () => any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt index a54d52e3475..08094932c45 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts (1 errors) ==== - function f() { var { arguments } = { arguments: "hello" }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js index 8a845ab0cb2..60044ac5dc4 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments17.ts] - function f() { var { arguments } = { arguments: "hello" }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js index 1d1a8ece338..0bcc93176a8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments17_ES6.ts] - function f() { var { arguments } = { arguments: "hello" }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols index a7d5e457056..ecf7c9ba46a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 0, 0)) var { arguments } = { arguments: "hello" }; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 5, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 25)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) @@ -16,5 +15,5 @@ function f() { >arguments : Symbol(arguments) } var arguments = "world"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 5, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types index 223663bdb1b..e0ea34ba0fe 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts === - function f() { >f : () => () => any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt index 2595b22801f..e4278c26824 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts (1 errors) ==== - function f() { var { arguments: args } = { arguments }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js index dc40302892b..a88a01c7a56 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments18.ts] - function f() { var { arguments: args } = { arguments }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js index ae9e7e4ef10..6e8a6a35b25 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments18_ES6.ts] - function f() { var { arguments: args } = { arguments }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols index e59ed6b8537..a10372c15d8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 0, 0)) var { arguments: args } = { arguments }; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31)) ->args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 9)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 31)) +>args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 9)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 31)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types index f2fe76e8926..040eef6748a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts === - function f() { >f : () => () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt index e6496443e7e..1db15e80798 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts(6,33): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts(5,33): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts (1 errors) ==== - function f() { function g() { var _arguments = 10; // No capture in 'g', so no conflict. diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js index 566c0aa49cd..95ed86c5047 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments19.ts] - function f() { function g() { var _arguments = 10; // No capture in 'g', so no conflict. diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js index e41aed4f4bf..80f83c245dc 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments19_ES6.ts] - function f() { function g() { var _arguments = 10; // No capture in 'g', so no conflict. diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols index 9e6392daaf1..05a23a28377 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols @@ -1,30 +1,29 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 0, 0)) function g() { ->g : Symbol(g, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 1, 14)) +>g : Symbol(g, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 0, 14)) var _arguments = 10; // No capture in 'g', so no conflict. ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 11)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 2, 11)) function h() { ->h : Symbol(h, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 28)) +>h : Symbol(h, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 2, 28)) var capture = () => arguments; // Should trigger an '_arguments' capture into function 'h' ->capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 15)) +>capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 4, 15)) >arguments : Symbol(arguments) foo(_arguments); // Error as this does not resolve to the user defined '_arguments' ->foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 8, 5)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 11)) +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 7, 5)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 2, 11)) } } function foo(x: any) { ->foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 8, 5)) ->x : Symbol(x, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 10, 17)) +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 7, 5)) +>x : Symbol(x, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 9, 17)) return 100; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types index 48d6f2e2935..284af00d344 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitBOM.js b/tests/baselines/reference/emitBOM.js index f243e715991..3f3d61fd2f9 100644 --- a/tests/baselines/reference/emitBOM.js +++ b/tests/baselines/reference/emitBOM.js @@ -1,5 +1,4 @@ //// [emitBOM.ts] - // JS and d.ts output should have a BOM but not the sourcemap var x; diff --git a/tests/baselines/reference/emitBOM.js.map b/tests/baselines/reference/emitBOM.js.map index 69ccb884295..d7a2f8d9780 100644 --- a/tests/baselines/reference/emitBOM.js.map +++ b/tests/baselines/reference/emitBOM.js.map @@ -1,2 +1,2 @@ //// [emitBOM.js.map] -{"version":3,"file":"emitBOM.js","sourceRoot":"","sources":["emitBOM.ts"],"names":[],"mappings":"AACA,6DAA6D;AAC7D,IAAI,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"emitBOM.js","sourceRoot":"","sources":["emitBOM.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,IAAI,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/emitBOM.sourcemap.txt b/tests/baselines/reference/emitBOM.sourcemap.txt index 4cf35c4d1e3..c88be299a74 100644 --- a/tests/baselines/reference/emitBOM.sourcemap.txt +++ b/tests/baselines/reference/emitBOM.sourcemap.txt @@ -11,11 +11,10 @@ sourceFile:emitBOM.ts >>>// JS and d.ts output should have a BOM but not the sourcemap 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -1 > - > +1 > 2 >// JS and d.ts output should have a BOM but not the sourcemap -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 62) Source(2, 62) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 62) Source(1, 62) + SourceIndex(0) --- >>>var x; 1 > @@ -28,9 +27,9 @@ sourceFile:emitBOM.ts 2 >var 3 > x 4 > ; -1 >Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 6) Source(3, 6) + SourceIndex(0) -4 >Emitted(2, 7) Source(3, 7) + SourceIndex(0) +1 >Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 6) Source(2, 6) + SourceIndex(0) +4 >Emitted(2, 7) Source(2, 7) + SourceIndex(0) --- >>>//# sourceMappingURL=emitBOM.js.map \ No newline at end of file diff --git a/tests/baselines/reference/emitBOM.symbols b/tests/baselines/reference/emitBOM.symbols index 85f495580d7..ab23b049080 100644 --- a/tests/baselines/reference/emitBOM.symbols +++ b/tests/baselines/reference/emitBOM.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/emitBOM.ts === - // JS and d.ts output should have a BOM but not the sourcemap var x; ->x : Symbol(x, Decl(emitBOM.ts, 2, 3)) +>x : Symbol(x, Decl(emitBOM.ts, 1, 3)) diff --git a/tests/baselines/reference/emitBOM.types b/tests/baselines/reference/emitBOM.types index b38fd19c8f4..0991acbac6f 100644 --- a/tests/baselines/reference/emitBOM.types +++ b/tests/baselines/reference/emitBOM.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitBOM.ts === - // JS and d.ts output should have a BOM but not the sourcemap var x; >x : any diff --git a/tests/baselines/reference/emitBundleWithShebang1.js b/tests/baselines/reference/emitBundleWithShebang1.js new file mode 100644 index 00000000000..a034d59f2a8 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang1.js @@ -0,0 +1,29 @@ +//// [emitBundleWithShebang1.ts] +#!/usr/bin/env gjs +class Doo {} +class Scooby extends Doo {} + +//// [outFile.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +#!/usr/bin/env gjs +var Doo = (function () { + function Doo() { + } + return Doo; +}()); +var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; +}(Doo)); diff --git a/tests/baselines/reference/emitBundleWithShebang1.symbols b/tests/baselines/reference/emitBundleWithShebang1.symbols new file mode 100644 index 00000000000..9763f6383cd --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/emitBundleWithShebang1.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Symbol(Doo, Decl(emitBundleWithShebang1.ts, 0, 0)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(emitBundleWithShebang1.ts, 1, 12)) +>Doo : Symbol(Doo, Decl(emitBundleWithShebang1.ts, 0, 0)) + diff --git a/tests/baselines/reference/emitBundleWithShebang1.types b/tests/baselines/reference/emitBundleWithShebang1.types new file mode 100644 index 00000000000..b3c69986530 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang1.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/emitBundleWithShebang1.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + diff --git a/tests/baselines/reference/emitBundleWithShebang2.js b/tests/baselines/reference/emitBundleWithShebang2.js new file mode 100644 index 00000000000..f771e52b922 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang2.js @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/emitBundleWithShebang2.ts] //// + +//// [test.ts] +#!/usr/bin/env gjs +class Doo {} +class Scooby extends Doo {} + +//// [test2.ts] +#!/usr/bin/env js +class Dood {} +class Scoobyd extends Dood {} + +//// [outFile.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +#!/usr/bin/env gjs +var Doo = (function () { + function Doo() { + } + return Doo; +}()); +var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; +}(Doo)); +#!/usr/bin/env js +var Dood = (function () { + function Dood() { + } + return Dood; +}()); +var Scoobyd = (function (_super) { + __extends(Scoobyd, _super); + function Scoobyd() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scoobyd; +}(Dood)); diff --git a/tests/baselines/reference/emitBundleWithShebang2.symbols b/tests/baselines/reference/emitBundleWithShebang2.symbols new file mode 100644 index 00000000000..effe73f3aef --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang2.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Symbol(Doo, Decl(test.ts, 0, 0)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(test.ts, 1, 12)) +>Doo : Symbol(Doo, Decl(test.ts, 0, 0)) + +=== tests/cases/compiler/test2.ts === +#!/usr/bin/env js +class Dood {} +>Dood : Symbol(Dood, Decl(test2.ts, 0, 0)) + +class Scoobyd extends Dood {} +>Scoobyd : Symbol(Scoobyd, Decl(test2.ts, 1, 13)) +>Dood : Symbol(Dood, Decl(test2.ts, 0, 0)) + diff --git a/tests/baselines/reference/emitBundleWithShebang2.types b/tests/baselines/reference/emitBundleWithShebang2.types new file mode 100644 index 00000000000..6310cd48406 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang2.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + +=== tests/cases/compiler/test2.ts === +#!/usr/bin/env js +class Dood {} +>Dood : Dood + +class Scoobyd extends Dood {} +>Scoobyd : Scoobyd +>Dood : Dood + diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js index 77b91730156..16c946c3e87 100644 --- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js +++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js @@ -1,5 +1,4 @@ //// [emitClassDeclarationWithSuperMethodCall01.ts] - class Parent { foo() { } diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols index dc749161623..27402b95ade 100644 --- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols +++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols @@ -1,24 +1,23 @@ === tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts === - class Parent { >Parent : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0)) foo() { ->foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14)) +>foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 14)) } } class Foo extends Parent { ->Foo : Symbol(Foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 4, 1)) +>Foo : Symbol(Foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 3, 1)) >Parent : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0)) foo() { ->foo : Symbol(Foo.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 6, 26)) +>foo : Symbol(Foo.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 5, 26)) var x = () => super.foo(); ->x : Symbol(x, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 8, 11)) ->super.foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14)) +>x : Symbol(x, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 7, 11)) +>super.foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 14)) >super : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0)) ->foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14)) +>foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 14)) } } diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types index 8b68af897ac..63d5d3a07ad 100644 --- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types +++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts === - class Parent { >Parent : Parent diff --git a/tests/baselines/reference/emitCommentsOnlyFile.js b/tests/baselines/reference/emitCommentsOnlyFile.js index d720dc3c191..23dddfa4849 100644 --- a/tests/baselines/reference/emitCommentsOnlyFile.js +++ b/tests/baselines/reference/emitCommentsOnlyFile.js @@ -1,5 +1,4 @@ //// [emitCommentsOnlyFile.ts] - /** * @name Foo * @class diff --git a/tests/baselines/reference/emitCommentsOnlyFile.symbols b/tests/baselines/reference/emitCommentsOnlyFile.symbols index 38b23eb128d..04e8f4a103a 100644 --- a/tests/baselines/reference/emitCommentsOnlyFile.symbols +++ b/tests/baselines/reference/emitCommentsOnlyFile.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/emitCommentsOnlyFile.ts === - -No type information for this code./** +/** No type information for this code.* @name Foo No type information for this code.* @class No type information for this code.*/ diff --git a/tests/baselines/reference/emitCommentsOnlyFile.types b/tests/baselines/reference/emitCommentsOnlyFile.types index 38b23eb128d..04e8f4a103a 100644 --- a/tests/baselines/reference/emitCommentsOnlyFile.types +++ b/tests/baselines/reference/emitCommentsOnlyFile.types @@ -1,6 +1,5 @@ === tests/cases/compiler/emitCommentsOnlyFile.ts === - -No type information for this code./** +/** No type information for this code.* @name Foo No type information for this code.* @class No type information for this code.*/ diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js index d94104a1c4b..050e36140de 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts] - var array0 = [1, 2, 3] var i0 = 0; array0[++i0] **= 2; diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols index 83f71871ec0..27174348d1a 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols @@ -1,51 +1,50 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts === - var array0 = [1, 2, 3] ->array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) +>array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 0, 3)) var i0 = 0; ->i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 2, 3)) +>i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) array0[++i0] **= 2; ->array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) ->i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 2, 3)) +>array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 0, 3)) +>i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) var array1 = [1, 2, 3] ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 4, 3)) var i1 = 0; ->i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3)) +>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) array1[++i1] **= array1[++i1] **= 2; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) ->i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) ->i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 4, 3)) +>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 4, 3)) +>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) var array2 = [1, 2, 3] ->array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) +>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 8, 3)) var i2 = 0; ->i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3)) +>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) array2[++i2] **= array2[++i2] ** 2; ->array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) ->i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3)) ->array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) ->i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3)) +>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 8, 3)) +>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) +>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 8, 3)) +>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) var array3 = [2, 2, 3]; ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) var j0 = 0, j1 = 1; ->j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3)) ->j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 11)) +>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) +>j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 11)) array3[j0++] **= array3[j1++] **= array3[j0++] **= 1; ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) ->j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3)) ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) ->j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 11)) ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) ->j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) +>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) +>j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 11)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) +>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types index ddb10cc9447..96ed4dfde4c 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts === - var array0 = [1, 2, 3] >array0 : number[] >[1, 2, 3] : number[] diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js index 66b9a7018fc..0410f77ad0c 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts] - var object = { _0: 2, get 0() { diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols index dbd5aa150dc..ac738dbf477 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols @@ -1,37 +1,36 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts === - var object = { ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) _0: 2, ->_0 : Symbol(_0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 14)) +>_0 : Symbol(_0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 14)) get 0() { return this._0; }, set 0(x: number) { ->x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 6, 10)) +>x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 10)) this._0 = x; ->x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 6, 10)) +>x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 10)) }, } object[0] **= object[0]; ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) object[0] **= object[0] **= 2; ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) object[0] **= object[0] ** 2; ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types index 32e5b33e411..0dfd96393c9 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts === - var object = { >object : { _0: number; 0: number; } >{ _0: 2, get 0() { return this._0; }, set 0(x: number) { this._0 = x; },} : { _0: number; 0: number; } diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js index d16e20c4cac..4ba9cff676d 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts] - var globalCounter = 0; function incrementIdx(max: number) { globalCounter += 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols index 19a9805a0c2..19ebc050163 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols @@ -1,60 +1,59 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts === - var globalCounter = 0; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 3)) function incrementIdx(max: number) { ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) ->max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 2, 22)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) +>max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) globalCounter += 1; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 3)) let idx = Math.floor(Math.random() * max); ->idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 4, 7)) +>idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 3, 7)) >Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >floor : Symbol(Math.floor, Decl(lib.d.ts, --, --)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) ->max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 2, 22)) +>max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) return idx; ->idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 4, 7)) +>idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 3, 7)) } var array1 = [1, 2, 3, 4, 5]; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) array1[incrementIdx(array1.length)] **= 3; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types index fec095dc696..c7488bb9bd2 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts === - var globalCounter = 0; >globalCounter : number >0 : 0 diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js index c6244161b19..90255262e60 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts] - var globalCounter = 0; function foo() { globalCounter += 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols index 6bdf5f331fb..2d7fb477b10 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols @@ -1,59 +1,58 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts === - var globalCounter = 0; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 3)) function foo() { ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) globalCounter += 1; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 3)) return { prop: 2 }; ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) } foo().prop **= 2; ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) var result0 = foo().prop **= 2; ->result0 : Symbol(result0, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 7, 3)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>result0 : Symbol(result0, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 6, 3)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) foo().prop **= foo().prop **= 2; ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) var result1 = foo().prop **= foo().prop **= 2; ->result1 : Symbol(result1, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 9, 3)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>result1 : Symbol(result1, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 8, 3)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) foo().prop **= foo().prop ** 2; ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) var result2 = foo().prop **= foo().prop ** 2; ->result2 : Symbol(result2, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 11, 3)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>result2 : Symbol(result2, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 10, 3)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types index 1a8a29bae9b..b4841f76cff 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts === - var globalCounter = 0; >globalCounter : number >0 : 0 diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.js b/tests/baselines/reference/emitCompoundExponentiationOperator1.js index cf72ce1d39f..79580f02f9f 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator1.js +++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationOperator1.ts] - var comp: number; comp **= 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols b/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols index a6a57c6fb88..e712bc8def4 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols @@ -1,83 +1,82 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts === - var comp: number; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= 1; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp ** 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp + 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp - 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp * 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp / 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp % 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp - 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp + 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp * 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp / 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp % 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 + 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 - 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 * 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 / 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 % 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.types b/tests/baselines/reference/emitCompoundExponentiationOperator1.types index 6a4a5b5bab9..55dde21b8fe 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator1.types +++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts === - var comp: number; >comp : number diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.js b/tests/baselines/reference/emitCompoundExponentiationOperator2.js index 91b988423ac..1f2a475cea0 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator2.js +++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationOperator2.ts] - var comp: number; comp **= 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols b/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols index 04a22b2782c..d510c2fe9ae 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols @@ -1,76 +1,75 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts === - var comp: number; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= 1; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 + 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 - 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 * 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 / 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 + 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 - 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 * 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 / 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 + 2 ** 3; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 - 2 ** 4; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 * 2 ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 / 2 ** 6; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 + 2) ** 3; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 - 2) ** 4; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 * 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 / 2) ** 6; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.types b/tests/baselines/reference/emitCompoundExponentiationOperator2.types index f715a9593f2..948ad6d3e5d 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator2.types +++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts === - var comp: number; >comp : number diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.js b/tests/baselines/reference/emitDecoratorMetadata_restArgs.js index 4bc1f023212..862a1baa025 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.js +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.js @@ -1,5 +1,4 @@ //// [emitDecoratorMetadata_restArgs.ts] - declare const MyClassDecorator: ClassDecorator; declare const MyMethodDecorator: MethodDecorator; diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols b/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols index 29ccb8b2711..c37ca0b8e4d 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols @@ -1,45 +1,44 @@ === tests/cases/compiler/emitDecoratorMetadata_restArgs.ts === - declare const MyClassDecorator: ClassDecorator; ->MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 0, 13)) >ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) declare const MyMethodDecorator: MethodDecorator; ->MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) >MethodDecorator : Symbol(MethodDecorator, Decl(lib.d.ts, --, --)) @MyClassDecorator ->MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 0, 13)) class A { ->A : Symbol(A, Decl(emitDecoratorMetadata_restArgs.ts, 2, 49)) +>A : Symbol(A, Decl(emitDecoratorMetadata_restArgs.ts, 1, 49)) constructor(...args) {} ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 6, 16)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 5, 16)) @MyMethodDecorator ->MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) method(...args) {} ->method : Symbol(A.method, Decl(emitDecoratorMetadata_restArgs.ts, 6, 27)) ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 8, 11)) +>method : Symbol(A.method, Decl(emitDecoratorMetadata_restArgs.ts, 5, 27)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 7, 11)) } @MyClassDecorator ->MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 0, 13)) class B { ->B : Symbol(B, Decl(emitDecoratorMetadata_restArgs.ts, 9, 1)) +>B : Symbol(B, Decl(emitDecoratorMetadata_restArgs.ts, 8, 1)) constructor(...args: number[]) {} ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 13, 16)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 12, 16)) @MyMethodDecorator ->MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) method(this: this, ...args: string[]) {} ->method : Symbol(B.method, Decl(emitDecoratorMetadata_restArgs.ts, 13, 37)) ->this : Symbol(this, Decl(emitDecoratorMetadata_restArgs.ts, 15, 11)) ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 15, 22)) +>method : Symbol(B.method, Decl(emitDecoratorMetadata_restArgs.ts, 12, 37)) +>this : Symbol(this, Decl(emitDecoratorMetadata_restArgs.ts, 14, 11)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 14, 22)) } diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.types b/tests/baselines/reference/emitDecoratorMetadata_restArgs.types index 8161634a092..5fc9a7b0ed0 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.types +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitDecoratorMetadata_restArgs.ts === - declare const MyClassDecorator: ClassDecorator; >MyClassDecorator : ClassDecorator >ClassDecorator : ClassDecorator diff --git a/tests/baselines/reference/emitExponentiationOperator1.js b/tests/baselines/reference/emitExponentiationOperator1.js index 2b270ef708b..00baa9e1b87 100644 --- a/tests/baselines/reference/emitExponentiationOperator1.js +++ b/tests/baselines/reference/emitExponentiationOperator1.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperator1.ts] - 1 ** -2; 1 ** 2; (-1) ** 2 diff --git a/tests/baselines/reference/emitExponentiationOperator1.symbols b/tests/baselines/reference/emitExponentiationOperator1.symbols index 5fb3419d419..9a86abe3f9a 100644 --- a/tests/baselines/reference/emitExponentiationOperator1.symbols +++ b/tests/baselines/reference/emitExponentiationOperator1.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts === - -No type information for this code.1 ** -2; +1 ** -2; No type information for this code.1 ** 2; No type information for this code.(-1) ** 2 No type information for this code.1 ** 2 ** 3; diff --git a/tests/baselines/reference/emitExponentiationOperator1.types b/tests/baselines/reference/emitExponentiationOperator1.types index 9db01d34f22..34ccbec9e26 100644 --- a/tests/baselines/reference/emitExponentiationOperator1.types +++ b/tests/baselines/reference/emitExponentiationOperator1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts === - 1 ** -2; >1 ** -2 : number >1 : 1 diff --git a/tests/baselines/reference/emitExponentiationOperator2.js b/tests/baselines/reference/emitExponentiationOperator2.js index 46f80b44bba..9eee0c3a246 100644 --- a/tests/baselines/reference/emitExponentiationOperator2.js +++ b/tests/baselines/reference/emitExponentiationOperator2.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperator2.ts] - var temp = 10; ++temp ** 3; diff --git a/tests/baselines/reference/emitExponentiationOperator2.symbols b/tests/baselines/reference/emitExponentiationOperator2.symbols index c3d9e4b25df..25303debc65 100644 --- a/tests/baselines/reference/emitExponentiationOperator2.symbols +++ b/tests/baselines/reference/emitExponentiationOperator2.symbols @@ -1,152 +1,151 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts === - var temp = 10; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp++ ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp + temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp - temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp * temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp / temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp % temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp++ ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- ** -temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp++ ** +temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- + temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- - temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- * temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- / temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- % temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp + 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp - 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp * 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp / 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp % 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp + 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp - 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp * 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp / 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp++ ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp-- ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp + 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp - 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp * 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp / 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp % 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp + 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp - 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp * 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp / 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp % 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperator2.types b/tests/baselines/reference/emitExponentiationOperator2.types index b2936f6acef..288aafc0f89 100644 --- a/tests/baselines/reference/emitExponentiationOperator2.types +++ b/tests/baselines/reference/emitExponentiationOperator2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts === - var temp = 10; >temp : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperator3.js b/tests/baselines/reference/emitExponentiationOperator3.js index ceb08c868db..cff2b2685b1 100644 --- a/tests/baselines/reference/emitExponentiationOperator3.js +++ b/tests/baselines/reference/emitExponentiationOperator3.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperator3.ts] - var temp = 10; (-++temp) ** 3; diff --git a/tests/baselines/reference/emitExponentiationOperator3.symbols b/tests/baselines/reference/emitExponentiationOperator3.symbols index 23111743855..70adf2b1565 100644 --- a/tests/baselines/reference/emitExponentiationOperator3.symbols +++ b/tests/baselines/reference/emitExponentiationOperator3.symbols @@ -1,107 +1,106 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts === - var temp = 10; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-++temp) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+--temp) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-temp++) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+temp--) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** ++temp)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** --temp)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** temp++)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** temp--)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** ++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** --temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** ++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** --temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp++ ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp-- ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** ++temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** --temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp++ ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp-- ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** ++temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** --temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** -temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** -temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** -++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** +--temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (-temp++) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (-temp--) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (+temp++) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (+temp--) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (-++temp) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (+--temp) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperator3.types b/tests/baselines/reference/emitExponentiationOperator3.types index 38bb5a0895c..2fe95d4db8f 100644 --- a/tests/baselines/reference/emitExponentiationOperator3.types +++ b/tests/baselines/reference/emitExponentiationOperator3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts === - var temp = 10; >temp : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js index c3c589e6a61..379af45e0f7 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTempalteString4.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols index 7892323ef1d..c9f708f317e 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols @@ -1,114 +1,113 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) // With TemplateTail `${t1 ** -t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) `${(-t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-++t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-t1++) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) // TempateHead & TemplateTail are empt `${t1 ** -t2} hello world ${t1 ** -t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) `${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) ** - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) // With templateHead `hello ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${(-++t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${(-t1++) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types index d11846227f2..08bb88d6965 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js index bda3f8be251..2bc249a86a4 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTempalteString4ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols index 1f4cd74502b..1e5528b695f 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols @@ -1,114 +1,113 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) // With TemplateTail `${t1 ** -t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) `${(-t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-++t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-t1++) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) // TempateHead & TemplateTail are empt `${t1 ** -t2} hello world ${t1 ** -t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) `${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) ** - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) // With templateHead `hello ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${(-++t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${(-t1++) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types index 610c3a64a6e..0918c28892a 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js index cd9ac32bbd2..dbfd5987156 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString1.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols index 8830135987e..a79786f94b0 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) // TempateHead & TemplateTail are empty `${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) `${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types index 4f78cd61fcc..326c947735b 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js index d32caf45106..2d3623b30c9 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString1ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols index 7b07fa26bba..89e5f039bc1 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) // TempateHead & TemplateTail are empty `${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) `${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types index 0bc65c31b12..2aa89e26587 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js index cd73e04327f..93604d0e00f 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString2.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols index 224499c1289..d7048267556 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) // With templateHead `hello ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) `hello ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) `hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) `hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types index 9b77f4bc3fc..c7e861e8a39 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js index ac92b4598aa..5263bb8e420 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString2ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols index fd674b21d33..045f232e869 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) // With templateHead `hello ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) `hello ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) `hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) `hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types index ed0be973e5b..31c845f91b8 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js index 966464b8220..93333a3a8df 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString3.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols index 758a0e2956b..7d4dd49c394 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) // With TemplateTail `${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) `${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t2 + t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2}${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types index 16fe31dde5e..6e0dea6b9dc 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js index ec037dd2150..b5f0e48677f 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString3ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols index a6062348432..4192ac635dc 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) // With TemplateTail `${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) `${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2}${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types index 86eb42efc05..0ea9f7db87c 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitPostComments.js b/tests/baselines/reference/emitPostComments.js index 8a5736af00d..c37e097a7cf 100644 --- a/tests/baselines/reference/emitPostComments.js +++ b/tests/baselines/reference/emitPostComments.js @@ -1,5 +1,4 @@ //// [emitPostComments.ts] - var y = 10; /** * @name Foo diff --git a/tests/baselines/reference/emitPostComments.symbols b/tests/baselines/reference/emitPostComments.symbols index 296d8081058..8c8cd4a9f8a 100644 --- a/tests/baselines/reference/emitPostComments.symbols +++ b/tests/baselines/reference/emitPostComments.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/emitPostComments.ts === - var y = 10; ->y : Symbol(y, Decl(emitPostComments.ts, 1, 3)) +>y : Symbol(y, Decl(emitPostComments.ts, 0, 3)) /** * @name Foo diff --git a/tests/baselines/reference/emitPostComments.types b/tests/baselines/reference/emitPostComments.types index dd73d852423..419bc6e2408 100644 --- a/tests/baselines/reference/emitPostComments.types +++ b/tests/baselines/reference/emitPostComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitPostComments.ts === - var y = 10; >y : number >10 : 10 diff --git a/tests/baselines/reference/emitPreComments.js b/tests/baselines/reference/emitPreComments.js index 4ca3297fce7..2694fa5b47d 100644 --- a/tests/baselines/reference/emitPreComments.js +++ b/tests/baselines/reference/emitPreComments.js @@ -1,5 +1,4 @@ //// [emitPreComments.ts] - // This is pre comment var y = 10; /** diff --git a/tests/baselines/reference/emitPreComments.symbols b/tests/baselines/reference/emitPreComments.symbols index c90547bb6b8..321295930c6 100644 --- a/tests/baselines/reference/emitPreComments.symbols +++ b/tests/baselines/reference/emitPreComments.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/emitPreComments.ts === - // This is pre comment var y = 10; ->y : Symbol(y, Decl(emitPreComments.ts, 2, 3)) +>y : Symbol(y, Decl(emitPreComments.ts, 1, 3)) /** * @name Foo diff --git a/tests/baselines/reference/emitPreComments.types b/tests/baselines/reference/emitPreComments.types index 5ba8e45f721..557def62fb5 100644 --- a/tests/baselines/reference/emitPreComments.types +++ b/tests/baselines/reference/emitPreComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitPreComments.ts === - // This is pre comment var y = 10; >y : number diff --git a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js index ff358518568..387f700e8e9 100644 --- a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js +++ b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.ts] //// //// [file0.ts] - var x = 10 //// [file1.ts] diff --git a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols index 1c0e48e00f2..efec6d76606 100644 --- a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols +++ b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols @@ -10,7 +10,6 @@ interface F { } === tests/cases/compiler/file0.ts === - var x = 10 ->x : Symbol(x, Decl(file0.ts, 1, 3)) +>x : Symbol(x, Decl(file0.ts, 0, 3)) diff --git a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types index b5c1cd2b346..2d0223f90ab 100644 --- a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types +++ b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types @@ -10,7 +10,6 @@ interface F { } === tests/cases/compiler/file0.ts === - var x = 10 >x : number >10 : 10 diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js index 1eb76741e84..d310fa64572 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter01.ts] - function f([]) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols index e1630be639b..cbd0f64e766 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts === - function f([]) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter01.ts, 0, 0)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.types b/tests/baselines/reference/emptyArrayBindingPatternParameter01.types index 4ca0b892ecf..7665ee42d86 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts === - function f([]) { >f : ([]: any[]) => void diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js index d6dda16e12f..6f8b36b665e 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter02.ts] - function f(a, []) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols index 3289c06f962..3973cf9a7e0 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts === - function f(a, []) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter02.ts, 0, 0)) ->a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 1, 11)) +>a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 0, 11)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types index 34d9e7dde6b..f944bb3349b 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts === - function f(a, []) { >f : (a: any, []: any[]) => void >a : any diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js index 4867b39ac2f..3e632bf0416 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter03.ts] - function f(a, []) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols index 86a95687310..d9b6784661e 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts === - function f(a, []) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter03.ts, 0, 0)) ->a : Symbol(a, Decl(emptyArrayBindingPatternParameter03.ts, 1, 11)) +>a : Symbol(a, Decl(emptyArrayBindingPatternParameter03.ts, 0, 11)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types index 1c5579ebe36..922870dce9f 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts === - function f(a, []) { >f : (a: any, []: any[]) => void >a : any diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js index 69266916935..1405cf6ecf5 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter04.ts] - function f([] = [1,2,3,4]) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols index 9f4c9bae0c6..9b559dfe81c 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts === - function f([] = [1,2,3,4]) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter04.ts, 0, 0)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter04.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter04.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter04.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter04.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter04.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter04.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.types b/tests/baselines/reference/emptyArrayBindingPatternParameter04.types index f6035a6ba94..16e65f159de 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts === - function f([] = [1,2,3,4]) { >f : ([]?: number[]) => void >[1,2,3,4] : number[] diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js index fe0a642c51e..bd7ca293446 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns01_ES5.ts] - var a: any; ({} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols index 97752a1358d..e8c3f93c013 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 0, 3)) ({} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 0, 3)) ([] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types index cbc0a25b074..b298c7f66ee 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js index 7123841025f..d3c41ea46a2 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns01_ES5iterable.ts] - var a: any; ({} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols index 8811c61dd9e..9d5fed49105 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 0, 3)) ({} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 0, 3)) ([] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types index 4a5e17d7cde..4f60d19cfd1 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js index 4cf33452d98..ab90b7cd89b 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns01_ES6.ts] - var a: any; ({} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols index 345bdd52265..d12e52ba1e8 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 0, 3)) ({} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 0, 3)) ([] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types index c22c0e72854..770547f9e7b 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js index f5434d4a1c3..2c4743b90f3 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns02_ES5.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols index a575ea35f24..a77099dbfa0 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 20)) ({} = { x, y, z } = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 4, 7)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 4, 10)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 4, 13)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 3, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 3, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 3, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 0, 3)) ([] = [ a1, a2, a3] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types index 76897f8516e..383afeb7c9d 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js index 45cd426549e..bcd57cff25c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns02_ES5iterable.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols index fc90df74d1d..b8222c4da9c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 20)) ({} = { x, y, z } = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 7)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 10)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 13)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 3, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 3, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 3, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 0, 3)) ([] = [ a1, a2, a3] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types index 5f19cd98ec4..e75fca12e0f 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js index 493246c9473..df05fb669ee 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns02_ES6.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols index e55339cb658..34659f0e348 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 20)) ({} = { x, y, z } = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 4, 7)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 4, 10)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 4, 13)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 3, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 3, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 3, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 0, 3)) ([] = [ a1, a2, a3] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types index 48c9146e154..b62aba04e7c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js index adaad2e3b63..26d59e28b51 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns03_ES5.ts] - var a: any; ({} = {} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols index c57365bc7d0..d7e5cd265fc 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 0, 3)) ({} = {} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 0, 3)) ([] = [] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types index 4f32b0555ef..76c63ca761c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js index 79806e5994d..925e15918db 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns03_ES5iterable.ts] - var a: any; ({} = {} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols index e1ac0ea4c5c..4b066259d18 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 0, 3)) ({} = {} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 0, 3)) ([] = [] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types index 273d360d92f..5e7b867f44b 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js index 8050cc1e47a..2a3e1462bca 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns03_ES6.ts] - var a: any; ({} = {} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols index 3e32848207a..9df1375cb55 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 0, 3)) ({} = {} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 0, 3)) ([] = [] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types index 1f1d005aac5..9e826e4b92b 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js index 91559d18252..d2c3c1a1fa9 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns04_ES5.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols index 20ea8c037c3..b362119333e 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 20)) ({ x, y, z } = {} = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 4, 2)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 4, 5)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 4, 8)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 3, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 3, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 3, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 0, 3)) ([ a1, a2, a3] = [] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types index 5ae2f0674fa..0c867291777 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js index 5cb4a63b03d..36c124be511 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns04_ES5iterable.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols index d433a0f125c..f2b185f5c15 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 20)) ({ x, y, z } = {} = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 2)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 5)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 8)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 3, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 3, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 3, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 0, 3)) ([ a1, a2, a3] = [] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types index c926ec31bfa..cfd3991852c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js index fb52975d6d1..a00bc8d0c66 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns04_ES6.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols index ee793cd3187..cfbe128fcdb 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 20)) ({ x, y, z } = {} = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 4, 2)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 4, 5)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 4, 8)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 3, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 3, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 3, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 0, 3)) ([ a1, a2, a3] = [] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types index 6bd85593748..d92c91b0576 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js index 6a8ec808cd0..92b516377fd 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter01.ts] - function f({}) { var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols index 3ef5898c29a..464b0a170a3 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts === - function f({}) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter01.ts, 0, 0)) var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 2, 7)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 2, 10)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 2, 13)) +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 1, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 1, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types index 05ddc54719c..d2326c5e18c 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts === - function f({}) { >f : ({}: {}) => void diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js index be2bdcab298..35488656e22 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter02.ts] - function f(a, {}) { var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols index d5bb4f292aa..cf3f36d7208 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts === - function f(a, {}) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter02.ts, 0, 0)) ->a : Symbol(a, Decl(emptyObjectBindingPatternParameter02.ts, 1, 11)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter02.ts, 0, 11)) var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 2, 7)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 2, 10)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 2, 13)) +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 1, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 1, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types index e2b485538e6..56b50e11602 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts === - function f(a, {}) { >f : (a: any, {}: {}) => void >a : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js index 320bfe2d0df..e4ce7e6fc39 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter03.ts] - function f({}, a) { var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols index 82a1bcee75b..87c584a4634 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts === - function f({}, a) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter03.ts, 0, 0)) ->a : Symbol(a, Decl(emptyObjectBindingPatternParameter03.ts, 1, 14)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter03.ts, 0, 14)) var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 2, 7)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 2, 10)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 2, 13)) +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 1, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 1, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types index 0f89702402a..c5938402d0a 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts === - function f({}, a) { >f : ({}: {}, a: any) => void >a : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt b/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt index 03b58378a0f..52b69127f79 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(2,18): error TS2353: Object literal may only specify known properties, and 'a' does not exist in type '{}'. -tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(2,24): error TS2353: Object literal may only specify known properties, and 'b' does not exist in type '{}'. -tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(2,32): error TS2353: Object literal may only specify known properties, and 'c' does not exist in type '{}'. +tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(1,18): error TS2353: Object literal may only specify known properties, and 'a' does not exist in type '{}'. +tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(1,24): error TS2353: Object literal may only specify known properties, and 'b' does not exist in type '{}'. +tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(1,32): error TS2353: Object literal may only specify known properties, and 'c' does not exist in type '{}'. ==== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts (3 errors) ==== - function f({} = {a: 1, b: "2", c: true}) { ~ !!! error TS2353: Object literal may only specify known properties, and 'a' does not exist in type '{}'. diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js index 8d91e8f34c3..c18ae67ac4b 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter04.ts] - function f({} = {a: 1, b: "2", c: true}) { var x, y, z; } diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt b/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt index 4d70873bd74..bfe850a5749 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt +++ b/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts(2,10): error TS1122: A tuple type element list cannot be empty. +tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts(1,10): error TS1122: A tuple type element list cannot be empty. ==== tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts (1 errors) ==== - let x = <[]>[]; ~~ !!! error TS1122: A tuple type element list cannot be empty. diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion01.js b/tests/baselines/reference/emptyTuplesTypeAssertion01.js index 6ab1ec82bd5..8ee48da9a56 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion01.js +++ b/tests/baselines/reference/emptyTuplesTypeAssertion01.js @@ -1,5 +1,4 @@ //// [emptyTuplesTypeAssertion01.ts] - let x = <[]>[]; let y = x[0]; diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt b/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt index 0cbc0d7371c..1bbf96e6aec 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt +++ b/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts(2,15): error TS1122: A tuple type element list cannot be empty. +tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts(1,15): error TS1122: A tuple type element list cannot be empty. ==== tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts (1 errors) ==== - let x = [] as []; ~~ !!! error TS1122: A tuple type element list cannot be empty. diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion02.js b/tests/baselines/reference/emptyTuplesTypeAssertion02.js index ad112732cd2..41607e53b40 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion02.js +++ b/tests/baselines/reference/emptyTuplesTypeAssertion02.js @@ -1,5 +1,4 @@ //// [emptyTuplesTypeAssertion02.ts] - let x = [] as []; let y = x[0]; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js index 655a9f073a2..c9b30a93906 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns01_ES5.ts] - (function () { var a: any; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols index ddba9738e08..84351c06f0a 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5.ts === - (function () { var a: any; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 21, 5)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 20, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) return ({} = a, [] = a, { p: {} = a } = a) => a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) } })(); (function () { const ns: number[][] = []; ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) for (var {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (let {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (const {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (var [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (let [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (const [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } })(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types index 9b6112365fd..c61c80c5b3d 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5.ts === - (function () { >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js index c4eeb9994e6..d4632999e0c 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns01_ES5iterable.ts] - (function () { var a: any; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols index d77525cf767..38b911d7071 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5iterable.ts === - (function () { var a: any; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 21, 5)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 20, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) return ({} = a, [] = a, { p: {} = a } = a) => a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) } })(); (function () { const ns: number[][] = []; ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) for (var {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (let {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (const {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (var [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (let [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (const [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } })(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types index 591b149ac07..9c623fd8879 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5iterable.ts === - (function () { >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js index 98661c440c6..86bb3ca0a89 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns01_ES6.ts] - (function () { var a: any; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols index 6a826d4b6c9..604e948aba9 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES6.ts === - (function () { var a: any; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 21, 5)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 20, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) return ({} = a, [] = a, { p: {} = a } = a) => a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) } })(); (function () { const ns: number[][] = []; ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) for (var {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (let {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (const {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (var [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (let [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (const [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } })(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types index ac79fe0b1b7..48d5f40b971 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES6.ts === - (function () { >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt index b589b075ecb..5825a43c28d 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt @@ -1,13 +1,12 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(2,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(3,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(4,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(4,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(6,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(7,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(8,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(9,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(8,11): error TS1182: A destructuring declaration must have an initializer. ==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts (6 errors) ==== - (function () { var {}; ~~ diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js index 7710b5e26c1..1fbb527a827 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns02_ES5.ts] - (function () { var {}; let {}; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt index 453f44be10c..29c51ecd3f2 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt @@ -1,13 +1,12 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(2,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(3,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(4,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(4,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(6,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(7,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(8,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(9,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(8,11): error TS1182: A destructuring declaration must have an initializer. ==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts (6 errors) ==== - (function () { var {}; ~~ diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js index b5457d0a2ec..24ba247daf8 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns02_ES5iterable.ts] - (function () { var {}; let {}; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt index 81349584f47..ffd6ab09cf7 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt @@ -1,13 +1,12 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(2,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(3,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(4,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(4,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(6,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(7,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(8,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(9,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(8,11): error TS1182: A destructuring declaration must have an initializer. ==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts (6 errors) ==== - (function () { var {}; ~~ diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js index 9b78828cc49..41f362f79fc 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns02_ES6.ts] - (function () { var {}; let {}; diff --git a/tests/baselines/reference/enumDecl1.js b/tests/baselines/reference/enumDecl1.js index fb1c00a19a6..383f463d51c 100644 --- a/tests/baselines/reference/enumDecl1.js +++ b/tests/baselines/reference/enumDecl1.js @@ -1,5 +1,4 @@ //// [enumDecl1.ts] - declare module mAmbient { enum e { x, diff --git a/tests/baselines/reference/enumDecl1.symbols b/tests/baselines/reference/enumDecl1.symbols index fc8d900ff04..71f6e48e553 100644 --- a/tests/baselines/reference/enumDecl1.symbols +++ b/tests/baselines/reference/enumDecl1.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/enumDecl1.ts === - declare module mAmbient { >mAmbient : Symbol(mAmbient, Decl(enumDecl1.ts, 0, 0)) enum e { ->e : Symbol(e, Decl(enumDecl1.ts, 1, 25)) +>e : Symbol(e, Decl(enumDecl1.ts, 0, 25)) x, ->x : Symbol(e.x, Decl(enumDecl1.ts, 2, 12)) +>x : Symbol(e.x, Decl(enumDecl1.ts, 1, 12)) y, ->y : Symbol(e.y, Decl(enumDecl1.ts, 3, 10)) +>y : Symbol(e.y, Decl(enumDecl1.ts, 2, 10)) z ->z : Symbol(e.z, Decl(enumDecl1.ts, 4, 10)) +>z : Symbol(e.z, Decl(enumDecl1.ts, 3, 10)) } } diff --git a/tests/baselines/reference/enumDecl1.types b/tests/baselines/reference/enumDecl1.types index 22d2b6b4d69..3f73e33f932 100644 --- a/tests/baselines/reference/enumDecl1.types +++ b/tests/baselines/reference/enumDecl1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/enumDecl1.ts === - declare module mAmbient { >mAmbient : typeof mAmbient diff --git a/tests/baselines/reference/enumLiteralTypes2.js b/tests/baselines/reference/enumLiteralTypes2.js index 0b2b6d35c53..a7d6f112800 100644 --- a/tests/baselines/reference/enumLiteralTypes2.js +++ b/tests/baselines/reference/enumLiteralTypes2.js @@ -1,5 +1,4 @@ //// [enumLiteralTypes2.ts] - const enum Choice { Unknown, Yes, No }; type YesNo = Choice.Yes | Choice.No; diff --git a/tests/baselines/reference/enumLiteralTypes2.symbols b/tests/baselines/reference/enumLiteralTypes2.symbols index 3bd937c3706..951404c5f9e 100644 --- a/tests/baselines/reference/enumLiteralTypes2.symbols +++ b/tests/baselines/reference/enumLiteralTypes2.symbols @@ -1,412 +1,411 @@ === tests/cases/conformance/types/literal/enumLiteralTypes2.ts === - const enum Choice { Unknown, Yes, No }; >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 1, 19)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 0, 19)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) type YesNo = Choice.Yes | Choice.No; ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) type NoYes = Choice.No | Choice.Yes; ->NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 3, 36)) +>NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 2, 36)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No; ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 1, 19)) +>Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 0, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) function f1() { ->f1 : Symbol(f1, Decl(enumLiteralTypes2.ts, 5, 60)) +>f1 : Symbol(f1, Decl(enumLiteralTypes2.ts, 4, 60)) var a: YesNo; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) var a: NoYes; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) ->NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 3, 36)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) +>NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 2, 36)) var a: Choice.Yes | Choice.No; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) var a: Choice.No | Choice.Yes; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) } function f2(a: YesNo, b: UnknownYesNo, c: Choice) { ->f2 : Symbol(f2, Decl(enumLiteralTypes2.ts, 12, 1)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 14, 12)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 14, 21)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 14, 38)) +>f2 : Symbol(f2, Decl(enumLiteralTypes2.ts, 11, 1)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 13, 12)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 13, 21)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 13, 38)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) b = a; ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 14, 21)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 14, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 13, 21)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 13, 12)) c = a; ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 14, 38)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 14, 12)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 13, 38)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 13, 12)) c = b; ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 14, 38)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 14, 21)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 13, 38)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 13, 21)) } function f3(a: Choice.Yes, b: UnknownYesNo) { ->f3 : Symbol(f3, Decl(enumLiteralTypes2.ts, 18, 1)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) +>f3 : Symbol(f3, Decl(enumLiteralTypes2.ts, 17, 1)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) var x = a + b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a - b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a * b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a / b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a % b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a | b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a & b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a ^ b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = -b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = ~b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a == b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a != b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a === b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a !== b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a > b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a < b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a >= b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a <= b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = !b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) } function f4(a: Choice.Yes, b: UnknownYesNo) { ->f4 : Symbol(f4, Decl(enumLiteralTypes2.ts, 40, 1)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 42, 12)) +>f4 : Symbol(f4, Decl(enumLiteralTypes2.ts, 39, 1)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 41, 12)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 42, 26)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 41, 26)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) a++; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 42, 12)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 41, 12)) b++; ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 42, 26)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 41, 26)) } declare function g(x: Choice.Yes): string; ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 47, 19)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 46, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) declare function g(x: Choice.No): boolean; ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 48, 19)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 47, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) declare function g(x: Choice): number; ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 49, 19)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 48, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) function f5(a: YesNo, b: UnknownYesNo, c: Choice) { ->f5 : Symbol(f5, Decl(enumLiteralTypes2.ts, 49, 38)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 51, 12)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 51, 21)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 51, 38)) +>f5 : Symbol(f5, Decl(enumLiteralTypes2.ts, 48, 38)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 50, 12)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 50, 21)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 50, 38)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) var z1 = g(Choice.Yes); ->z1 : Symbol(z1, Decl(enumLiteralTypes2.ts, 52, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>z1 : Symbol(z1, Decl(enumLiteralTypes2.ts, 51, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) var z2 = g(Choice.No); ->z2 : Symbol(z2, Decl(enumLiteralTypes2.ts, 53, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>z2 : Symbol(z2, Decl(enumLiteralTypes2.ts, 52, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) var z3 = g(a); ->z3 : Symbol(z3, Decl(enumLiteralTypes2.ts, 54, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 51, 12)) +>z3 : Symbol(z3, Decl(enumLiteralTypes2.ts, 53, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 50, 12)) var z4 = g(b); ->z4 : Symbol(z4, Decl(enumLiteralTypes2.ts, 55, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 51, 21)) +>z4 : Symbol(z4, Decl(enumLiteralTypes2.ts, 54, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 50, 21)) var z5 = g(c); ->z5 : Symbol(z5, Decl(enumLiteralTypes2.ts, 56, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 51, 38)) +>z5 : Symbol(z5, Decl(enumLiteralTypes2.ts, 55, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 50, 38)) } function assertNever(x: never): never { ->assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 57, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 59, 21)) +>assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 56, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 58, 21)) throw new Error("Unexpected value"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f10(x: YesNo) { ->f10 : Symbol(f10, Decl(enumLiteralTypes2.ts, 61, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 63, 13)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>f10 : Symbol(f10, Decl(enumLiteralTypes2.ts, 60, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 62, 13)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) switch (x) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 63, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 62, 13)) case Choice.Yes: return "true"; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) case Choice.No: return "false"; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) } } function f11(x: YesNo) { ->f11 : Symbol(f11, Decl(enumLiteralTypes2.ts, 68, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 70, 13)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>f11 : Symbol(f11, Decl(enumLiteralTypes2.ts, 67, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 69, 13)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) switch (x) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 70, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 69, 13)) case Choice.Yes: return "true"; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) case Choice.No: return "false"; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 57, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 70, 13)) +>assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 56, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 69, 13)) } function f12(x: UnknownYesNo) { ->f12 : Symbol(f12, Decl(enumLiteralTypes2.ts, 76, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>f12 : Symbol(f12, Decl(enumLiteralTypes2.ts, 75, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) if (x) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) } else { x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) } } function f13(x: UnknownYesNo) { ->f13 : Symbol(f13, Decl(enumLiteralTypes2.ts, 85, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>f13 : Symbol(f13, Decl(enumLiteralTypes2.ts, 84, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) if (x === Choice.Yes) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) } else { x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) } } type Item = ->Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 94, 1)) +>Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 93, 1)) { kind: Choice.Yes, a: string } | ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) { kind: Choice.No, b: string }; ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 98, 5)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) function f20(x: Item) { ->f20 : Symbol(f20, Decl(enumLiteralTypes2.ts, 98, 35)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 94, 1)) +>f20 : Symbol(f20, Decl(enumLiteralTypes2.ts, 97, 35)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 93, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) +>x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) case Choice.Yes: return x.a; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) case Choice.No: return x.b; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) ->x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) +>x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) } } function f21(x: Item) { ->f21 : Symbol(f21, Decl(enumLiteralTypes2.ts, 105, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 94, 1)) +>f21 : Symbol(f21, Decl(enumLiteralTypes2.ts, 104, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 93, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) +>x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) case Choice.Yes: return x.a; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) case Choice.No: return x.b; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) ->x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) +>x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 57, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) +>assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 56, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) } diff --git a/tests/baselines/reference/enumLiteralTypes2.types b/tests/baselines/reference/enumLiteralTypes2.types index 6b881bee8c3..4a8c2ae01dc 100644 --- a/tests/baselines/reference/enumLiteralTypes2.types +++ b/tests/baselines/reference/enumLiteralTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/enumLiteralTypes2.ts === - const enum Choice { Unknown, Yes, No }; >Choice : Choice >Unknown : Choice.Unknown diff --git a/tests/baselines/reference/equalityStrictNulls.errors.txt b/tests/baselines/reference/equalityStrictNulls.errors.txt index 16772d8eeab..88694f5dddd 100644 --- a/tests/baselines/reference/equalityStrictNulls.errors.txt +++ b/tests/baselines/reference/equalityStrictNulls.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(60,13): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(62,13): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(64,14): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(66,14): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(59,13): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(61,13): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(63,14): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(65,14): error TS2532: Object is possibly 'undefined'. ==== tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts (4 errors) ==== - function f1(x: string) { if (x == undefined) { } diff --git a/tests/baselines/reference/equalityStrictNulls.js b/tests/baselines/reference/equalityStrictNulls.js index e34e9fe9989..650bd147a02 100644 --- a/tests/baselines/reference/equalityStrictNulls.js +++ b/tests/baselines/reference/equalityStrictNulls.js @@ -1,5 +1,4 @@ //// [equalityStrictNulls.ts] - function f1(x: string) { if (x == undefined) { } diff --git a/tests/baselines/reference/errorSupression1.errors.txt b/tests/baselines/reference/errorSupression1.errors.txt index 206a78ebf45..9977fa894ca 100644 --- a/tests/baselines/reference/errorSupression1.errors.txt +++ b/tests/baselines/reference/errorSupression1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/errorSupression1.ts(4,15): error TS2339: Property 'b' does not exist on type 'typeof Foo'. +tests/cases/compiler/errorSupression1.ts(3,15): error TS2339: Property 'b' does not exist on type 'typeof Foo'. ==== tests/cases/compiler/errorSupression1.ts (1 errors) ==== - class Foo { static bar() { return "x"; } } var baz = Foo.b; diff --git a/tests/baselines/reference/errorSupression1.js b/tests/baselines/reference/errorSupression1.js index 77545131ce3..e43e47adeda 100644 --- a/tests/baselines/reference/errorSupression1.js +++ b/tests/baselines/reference/errorSupression1.js @@ -1,5 +1,4 @@ //// [errorSupression1.ts] - class Foo { static bar() { return "x"; } } var baz = Foo.b; diff --git a/tests/baselines/reference/errorWithTruncatedType.errors.txt b/tests/baselines/reference/errorWithTruncatedType.errors.txt index f073f7c50a4..33714b86262 100644 --- a/tests/baselines/reference/errorWithTruncatedType.errors.txt +++ b/tests/baselines/reference/errorWithTruncatedType.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/errorWithTruncatedType.ts(11,5): error TS2322: Type '{ propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; propert...' is not assignable to type 'string'. +tests/cases/compiler/errorWithTruncatedType.ts(10,5): error TS2322: Type '{ propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; propert...' is not assignable to type 'string'. ==== tests/cases/compiler/errorWithTruncatedType.ts (1 errors) ==== - var x: { propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; diff --git a/tests/baselines/reference/errorWithTruncatedType.js b/tests/baselines/reference/errorWithTruncatedType.js index 5fd45579a29..3c47f229f36 100644 --- a/tests/baselines/reference/errorWithTruncatedType.js +++ b/tests/baselines/reference/errorWithTruncatedType.js @@ -1,5 +1,4 @@ //// [errorWithTruncatedType.ts] - var x: { propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; diff --git a/tests/baselines/reference/errorsInGenericTypeReference.errors.txt b/tests/baselines/reference/errorsInGenericTypeReference.errors.txt index 729b4db5440..c459eee9290 100644 --- a/tests/baselines/reference/errorsInGenericTypeReference.errors.txt +++ b/tests/baselines/reference/errorsInGenericTypeReference.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/errorsInGenericTypeReference.ts(12,17): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(18,31): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(23,29): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(24,36): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(25,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/errorsInGenericTypeReference.ts(25,27): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(26,24): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(31,36): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(35,36): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(39,17): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(43,33): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(45,41): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(48,27): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(52,25): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(57,35): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(61,39): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(66,22): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(66,38): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(67,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(11,17): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(17,31): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(22,29): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(23,36): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(24,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/errorsInGenericTypeReference.ts(24,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(25,24): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(30,36): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(34,36): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(38,17): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(42,33): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(44,41): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(47,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(51,25): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(56,35): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(60,39): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(65,22): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(65,38): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(66,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(67,24): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(67,40): error TS2304: Cannot find name 'V'. tests/cases/compiler/errorsInGenericTypeReference.ts(68,24): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(68,40): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(69,24): error TS2304: Cannot find name 'V'. ==== tests/cases/compiler/errorsInGenericTypeReference.ts (22 errors) ==== - interface IFoo { } class Foo { } diff --git a/tests/baselines/reference/errorsInGenericTypeReference.js b/tests/baselines/reference/errorsInGenericTypeReference.js index 2e54d0cf71c..ad999dcb913 100644 --- a/tests/baselines/reference/errorsInGenericTypeReference.js +++ b/tests/baselines/reference/errorsInGenericTypeReference.js @@ -1,5 +1,4 @@ //// [errorsInGenericTypeReference.ts] - interface IFoo { } class Foo { } diff --git a/tests/baselines/reference/errorsOnImportedSymbol.errors.txt b/tests/baselines/reference/errorsOnImportedSymbol.errors.txt index 127026a8e2c..52a0cf754c3 100644 --- a/tests/baselines/reference/errorsOnImportedSymbol.errors.txt +++ b/tests/baselines/reference/errorsOnImportedSymbol.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/errorsOnImportedSymbol_1.ts(3,9): error TS2693: 'Sammy' onl ==== tests/cases/compiler/errorsOnImportedSymbol_0.ts (0 errors) ==== - interface Sammy { new (): any; (): number; diff --git a/tests/baselines/reference/errorsOnImportedSymbol.js b/tests/baselines/reference/errorsOnImportedSymbol.js index 15ae0c90bd1..2d784b04d65 100644 --- a/tests/baselines/reference/errorsOnImportedSymbol.js +++ b/tests/baselines/reference/errorsOnImportedSymbol.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/errorsOnImportedSymbol.ts] //// //// [errorsOnImportedSymbol_0.ts] - interface Sammy { new (): any; (): number; diff --git a/tests/baselines/reference/es2015modulekind.js b/tests/baselines/reference/es2015modulekind.js index af638557fde..6e032e793cb 100644 --- a/tests/baselines/reference/es2015modulekind.js +++ b/tests/baselines/reference/es2015modulekind.js @@ -1,5 +1,4 @@ //// [es2015modulekind.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es2015modulekind.symbols b/tests/baselines/reference/es2015modulekind.symbols index 8a772e31895..fcfc1f1680f 100644 --- a/tests/baselines/reference/es2015modulekind.symbols +++ b/tests/baselines/reference/es2015modulekind.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekind.ts === - export default class A >A : Symbol(A, Decl(es2015modulekind.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es2015modulekind.ts, 6, 5)) +>B : Symbol(A.B, Decl(es2015modulekind.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es2015modulekind.types b/tests/baselines/reference/es2015modulekind.types index 1b09ecb0a88..749e30bc722 100644 --- a/tests/baselines/reference/es2015modulekind.types +++ b/tests/baselines/reference/es2015modulekind.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekind.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.js b/tests/baselines/reference/es2015modulekindWithES6Target.js index b76ab2a02a2..5f49db94b3b 100644 --- a/tests/baselines/reference/es2015modulekindWithES6Target.js +++ b/tests/baselines/reference/es2015modulekindWithES6Target.js @@ -1,5 +1,4 @@ //// [es2015modulekindWithES6Target.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.symbols b/tests/baselines/reference/es2015modulekindWithES6Target.symbols index 4a7c6469ca5..aaa44c84deb 100644 --- a/tests/baselines/reference/es2015modulekindWithES6Target.symbols +++ b/tests/baselines/reference/es2015modulekindWithES6Target.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekindWithES6Target.ts === - export default class A >A : Symbol(A, Decl(es2015modulekindWithES6Target.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es2015modulekindWithES6Target.ts, 6, 5)) +>B : Symbol(A.B, Decl(es2015modulekindWithES6Target.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.types b/tests/baselines/reference/es2015modulekindWithES6Target.types index 4872566b1c2..46b387f0182 100644 --- a/tests/baselines/reference/es2015modulekindWithES6Target.types +++ b/tests/baselines/reference/es2015modulekindWithES6Target.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekindWithES6Target.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es2017basicAsync.js b/tests/baselines/reference/es2017basicAsync.js index d0443c1899c..16baf6bc526 100644 --- a/tests/baselines/reference/es2017basicAsync.js +++ b/tests/baselines/reference/es2017basicAsync.js @@ -1,5 +1,4 @@ //// [es2017basicAsync.ts] - async (): Promise => { await 0; } diff --git a/tests/baselines/reference/es2017basicAsync.symbols b/tests/baselines/reference/es2017basicAsync.symbols index fc73741ba82..f1957cd94e5 100644 --- a/tests/baselines/reference/es2017basicAsync.symbols +++ b/tests/baselines/reference/es2017basicAsync.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es2017basicAsync.ts === - async (): Promise => { >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) @@ -7,20 +6,20 @@ async (): Promise => { } async function asyncFunc() { ->asyncFunc : Symbol(asyncFunc, Decl(es2017basicAsync.ts, 3, 1)) +>asyncFunc : Symbol(asyncFunc, Decl(es2017basicAsync.ts, 2, 1)) await 0; } const asyncArrowFunc = async (): Promise => { ->asyncArrowFunc : Symbol(asyncArrowFunc, Decl(es2017basicAsync.ts, 9, 5)) +>asyncArrowFunc : Symbol(asyncArrowFunc, Decl(es2017basicAsync.ts, 8, 5)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 0; } async function asyncIIFE() { ->asyncIIFE : Symbol(asyncIIFE, Decl(es2017basicAsync.ts, 11, 1)) +>asyncIIFE : Symbol(asyncIIFE, Decl(es2017basicAsync.ts, 10, 1)) await 0; @@ -31,7 +30,7 @@ async function asyncIIFE() { })(); await (async function asyncNamedFunc(): Promise { ->asyncNamedFunc : Symbol(asyncNamedFunc, Decl(es2017basicAsync.ts, 20, 11)) +>asyncNamedFunc : Symbol(asyncNamedFunc, Decl(es2017basicAsync.ts, 19, 11)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 1; @@ -45,32 +44,32 @@ async function asyncIIFE() { } class AsyncClass { ->AsyncClass : Symbol(AsyncClass, Decl(es2017basicAsync.ts, 27, 1)) +>AsyncClass : Symbol(AsyncClass, Decl(es2017basicAsync.ts, 26, 1)) asyncPropFunc = async function(): Promise { ->asyncPropFunc : Symbol(AsyncClass.asyncPropFunc, Decl(es2017basicAsync.ts, 29, 18)) +>asyncPropFunc : Symbol(AsyncClass.asyncPropFunc, Decl(es2017basicAsync.ts, 28, 18)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; } asyncPropNamedFunc = async function namedFunc(): Promise { ->asyncPropNamedFunc : Symbol(AsyncClass.asyncPropNamedFunc, Decl(es2017basicAsync.ts, 32, 5)) ->namedFunc : Symbol(namedFunc, Decl(es2017basicAsync.ts, 34, 24)) +>asyncPropNamedFunc : Symbol(AsyncClass.asyncPropNamedFunc, Decl(es2017basicAsync.ts, 31, 5)) +>namedFunc : Symbol(namedFunc, Decl(es2017basicAsync.ts, 33, 24)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; } asyncPropArrowFunc = async (): Promise => { ->asyncPropArrowFunc : Symbol(AsyncClass.asyncPropArrowFunc, Decl(es2017basicAsync.ts, 36, 5)) +>asyncPropArrowFunc : Symbol(AsyncClass.asyncPropArrowFunc, Decl(es2017basicAsync.ts, 35, 5)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; } async asyncMethod(): Promise { ->asyncMethod : Symbol(AsyncClass.asyncMethod, Decl(es2017basicAsync.ts, 40, 5)) +>asyncMethod : Symbol(AsyncClass.asyncMethod, Decl(es2017basicAsync.ts, 39, 5)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; diff --git a/tests/baselines/reference/es2017basicAsync.types b/tests/baselines/reference/es2017basicAsync.types index 30d19cb4dfe..7548cdcc06e 100644 --- a/tests/baselines/reference/es2017basicAsync.types +++ b/tests/baselines/reference/es2017basicAsync.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es2017basicAsync.ts === - async (): Promise => { >async (): Promise => { await 0;} : () => Promise >Promise : Promise diff --git a/tests/baselines/reference/es3-amd.js b/tests/baselines/reference/es3-amd.js index ecdbfe80b46..caa9552c3f0 100644 --- a/tests/baselines/reference/es3-amd.js +++ b/tests/baselines/reference/es3-amd.js @@ -1,5 +1,4 @@ //// [es3-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es3-amd.symbols b/tests/baselines/reference/es3-amd.symbols index 1f9efe3e590..86af83bc805 100644 --- a/tests/baselines/reference/es3-amd.symbols +++ b/tests/baselines/reference/es3-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-amd.ts === - class A >A : Symbol(A, Decl(es3-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es3-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es3-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es3-amd.types b/tests/baselines/reference/es3-amd.types index 420354f364a..f8a501850e3 100644 --- a/tests/baselines/reference/es3-amd.types +++ b/tests/baselines/reference/es3-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es3-declaration-amd.js b/tests/baselines/reference/es3-declaration-amd.js index 133cf33629a..0c447ff25b7 100644 --- a/tests/baselines/reference/es3-declaration-amd.js +++ b/tests/baselines/reference/es3-declaration-amd.js @@ -1,5 +1,4 @@ //// [es3-declaration-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es3-declaration-amd.symbols b/tests/baselines/reference/es3-declaration-amd.symbols index 5930b908e2f..537e0897123 100644 --- a/tests/baselines/reference/es3-declaration-amd.symbols +++ b/tests/baselines/reference/es3-declaration-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-declaration-amd.ts === - class A >A : Symbol(A, Decl(es3-declaration-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es3-declaration-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es3-declaration-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es3-declaration-amd.types b/tests/baselines/reference/es3-declaration-amd.types index c174d8d0255..823c2fe1da3 100644 --- a/tests/baselines/reference/es3-declaration-amd.types +++ b/tests/baselines/reference/es3-declaration-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-declaration-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es3-jsx-preserve.js b/tests/baselines/reference/es3-jsx-preserve.js index cb1ba2a887d..1a1419bb8da 100644 --- a/tests/baselines/reference/es3-jsx-preserve.js +++ b/tests/baselines/reference/es3-jsx-preserve.js @@ -1,5 +1,4 @@ //// [es3-jsx-preserve.tsx] - const React: any = null; const elem =
; diff --git a/tests/baselines/reference/es3-jsx-preserve.symbols b/tests/baselines/reference/es3-jsx-preserve.symbols index 61c9260223f..9083c113872 100644 --- a/tests/baselines/reference/es3-jsx-preserve.symbols +++ b/tests/baselines/reference/es3-jsx-preserve.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es3-jsx-preserve.tsx === - const React: any = null; ->React : Symbol(React, Decl(es3-jsx-preserve.tsx, 1, 5)) +>React : Symbol(React, Decl(es3-jsx-preserve.tsx, 0, 5)) const elem =
; ->elem : Symbol(elem, Decl(es3-jsx-preserve.tsx, 3, 5)) +>elem : Symbol(elem, Decl(es3-jsx-preserve.tsx, 2, 5)) >div : Symbol(unknown) >div : Symbol(unknown) diff --git a/tests/baselines/reference/es3-jsx-preserve.types b/tests/baselines/reference/es3-jsx-preserve.types index b37fe8af567..759870ffac5 100644 --- a/tests/baselines/reference/es3-jsx-preserve.types +++ b/tests/baselines/reference/es3-jsx-preserve.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-jsx-preserve.tsx === - const React: any = null; >React : any >null : null diff --git a/tests/baselines/reference/es3-jsx-react-native.js b/tests/baselines/reference/es3-jsx-react-native.js index 08e6e25502b..91f0ac46610 100644 --- a/tests/baselines/reference/es3-jsx-react-native.js +++ b/tests/baselines/reference/es3-jsx-react-native.js @@ -1,5 +1,4 @@ //// [es3-jsx-react-native.tsx] - const React: any = null; const elem =
; diff --git a/tests/baselines/reference/es3-jsx-react-native.symbols b/tests/baselines/reference/es3-jsx-react-native.symbols index e7f010bd2ea..6963318a8c5 100644 --- a/tests/baselines/reference/es3-jsx-react-native.symbols +++ b/tests/baselines/reference/es3-jsx-react-native.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es3-jsx-react-native.tsx === - const React: any = null; ->React : Symbol(React, Decl(es3-jsx-react-native.tsx, 1, 5)) +>React : Symbol(React, Decl(es3-jsx-react-native.tsx, 0, 5)) const elem =
; ->elem : Symbol(elem, Decl(es3-jsx-react-native.tsx, 3, 5)) +>elem : Symbol(elem, Decl(es3-jsx-react-native.tsx, 2, 5)) >div : Symbol(unknown) >div : Symbol(unknown) diff --git a/tests/baselines/reference/es3-jsx-react-native.types b/tests/baselines/reference/es3-jsx-react-native.types index 1bf199606f2..7cbfbe4684f 100644 --- a/tests/baselines/reference/es3-jsx-react-native.types +++ b/tests/baselines/reference/es3-jsx-react-native.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-jsx-react-native.tsx === - const React: any = null; >React : any >null : null diff --git a/tests/baselines/reference/es3-jsx-react.js b/tests/baselines/reference/es3-jsx-react.js index 861dde74c86..39d17767a71 100644 --- a/tests/baselines/reference/es3-jsx-react.js +++ b/tests/baselines/reference/es3-jsx-react.js @@ -1,5 +1,4 @@ //// [es3-jsx-react.tsx] - const React: any = null; const elem =
; diff --git a/tests/baselines/reference/es3-jsx-react.symbols b/tests/baselines/reference/es3-jsx-react.symbols index 465cfab7ea9..d5ebc65437c 100644 --- a/tests/baselines/reference/es3-jsx-react.symbols +++ b/tests/baselines/reference/es3-jsx-react.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es3-jsx-react.tsx === - const React: any = null; ->React : Symbol(React, Decl(es3-jsx-react.tsx, 1, 5)) +>React : Symbol(React, Decl(es3-jsx-react.tsx, 0, 5)) const elem =
; ->elem : Symbol(elem, Decl(es3-jsx-react.tsx, 3, 5)) +>elem : Symbol(elem, Decl(es3-jsx-react.tsx, 2, 5)) >div : Symbol(unknown) >div : Symbol(unknown) diff --git a/tests/baselines/reference/es3-jsx-react.types b/tests/baselines/reference/es3-jsx-react.types index b7734ffc1f0..089b3ad47cb 100644 --- a/tests/baselines/reference/es3-jsx-react.types +++ b/tests/baselines/reference/es3-jsx-react.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-jsx-react.tsx === - const React: any = null; >React : any >null : null diff --git a/tests/baselines/reference/es3-sourcemap-amd.js b/tests/baselines/reference/es3-sourcemap-amd.js index 4b16caec721..d135a0cad7f 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.js +++ b/tests/baselines/reference/es3-sourcemap-amd.js @@ -1,5 +1,4 @@ //// [es3-sourcemap-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es3-sourcemap-amd.js.map b/tests/baselines/reference/es3-sourcemap-amd.js.map index aa9f7aefe09..ea5ed85a88e 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.js.map +++ b/tests/baselines/reference/es3-sourcemap-amd.js.map @@ -1,2 +1,2 @@ //// [es3-sourcemap-amd.js.map] -{"version":3,"file":"es3-sourcemap-amd.js","sourceRoot":"","sources":["es3-sourcemap-amd.ts"],"names":[],"mappings":"AACA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file +{"version":3,"file":"es3-sourcemap-amd.js","sourceRoot":"","sources":["es3-sourcemap-amd.ts"],"names":[],"mappings":"AAAA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file diff --git a/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt b/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt index 9cb84dff0ba..d3b9d665ade 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt +++ b/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt @@ -11,9 +11,8 @@ sourceFile:es3-sourcemap-amd.ts >>>var A = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ @@ -21,7 +20,7 @@ sourceFile:es3-sourcemap-amd.ts 1->class A >{ > -1->Emitted(2, 5) Source(4, 5) + SourceIndex(0) +1->Emitted(2, 5) Source(3, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -32,8 +31,8 @@ sourceFile:es3-sourcemap-amd.ts > > 2 > } -1->Emitted(3, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(3, 6) Source(7, 6) + SourceIndex(0) +1->Emitted(3, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(3, 6) Source(6, 6) + SourceIndex(0) --- >>> A.prototype.B = function () { 1->^^^^ @@ -44,9 +43,9 @@ sourceFile:es3-sourcemap-amd.ts > public 2 > B 3 > -1->Emitted(4, 5) Source(9, 12) + SourceIndex(0) -2 >Emitted(4, 18) Source(9, 13) + SourceIndex(0) -3 >Emitted(4, 21) Source(9, 5) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 12) + SourceIndex(0) +2 >Emitted(4, 18) Source(8, 13) + SourceIndex(0) +3 >Emitted(4, 21) Source(8, 5) + SourceIndex(0) --- >>> return 42; 1 >^^^^^^^^ @@ -61,11 +60,11 @@ sourceFile:es3-sourcemap-amd.ts 3 > 4 > 42 5 > ; -1 >Emitted(5, 9) Source(11, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(11, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(11, 16) + SourceIndex(0) -4 >Emitted(5, 18) Source(11, 18) + SourceIndex(0) -5 >Emitted(5, 19) Source(11, 19) + SourceIndex(0) +1 >Emitted(5, 9) Source(10, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) +4 >Emitted(5, 18) Source(10, 18) + SourceIndex(0) +5 >Emitted(5, 19) Source(10, 19) + SourceIndex(0) --- >>> }; 1 >^^^^ @@ -74,8 +73,8 @@ sourceFile:es3-sourcemap-amd.ts 1 > > 2 > } -1 >Emitted(6, 5) Source(12, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(12, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) --- >>> return A; 1->^^^^ @@ -83,8 +82,8 @@ sourceFile:es3-sourcemap-amd.ts 1-> > 2 > } -1->Emitted(7, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(7, 13) Source(13, 2) + SourceIndex(0) +1->Emitted(7, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(7, 13) Source(12, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -107,9 +106,9 @@ sourceFile:es3-sourcemap-amd.ts > return 42; > } > } -1 >Emitted(8, 1) Source(13, 1) + SourceIndex(0) -2 >Emitted(8, 2) Source(13, 2) + SourceIndex(0) -3 >Emitted(8, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(8, 6) Source(13, 2) + SourceIndex(0) +1 >Emitted(8, 1) Source(12, 1) + SourceIndex(0) +2 >Emitted(8, 2) Source(12, 2) + SourceIndex(0) +3 >Emitted(8, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(8, 6) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=es3-sourcemap-amd.js.map \ No newline at end of file diff --git a/tests/baselines/reference/es3-sourcemap-amd.symbols b/tests/baselines/reference/es3-sourcemap-amd.symbols index 919e2cfa46c..841dd9c20ef 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.symbols +++ b/tests/baselines/reference/es3-sourcemap-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-sourcemap-amd.ts === - class A >A : Symbol(A, Decl(es3-sourcemap-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es3-sourcemap-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es3-sourcemap-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es3-sourcemap-amd.types b/tests/baselines/reference/es3-sourcemap-amd.types index 351cbe5ded9..0970c49fe1b 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.types +++ b/tests/baselines/reference/es3-sourcemap-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-sourcemap-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.js b/tests/baselines/reference/es3defaultAliasIsQuoted.js index d3bb3d006e5..ea12fc7a3d6 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.js +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es3defaultAliasIsQuoted.ts] //// //// [es3defaultAliasQuoted_file0.ts] - export class Foo { static CONSTANT = "Foo"; } diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols index 3472258373e..16ba6ccdcf9 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/es3defaultAliasQuoted_file0.ts === - export class Foo { >Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file0.ts, 0, 0)) static CONSTANT = "Foo"; ->CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18)) +>CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 0, 18)) } export default function assert(value: boolean) { ->assert : Symbol(assert, Decl(es3defaultAliasQuoted_file0.ts, 3, 1)) ->value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31)) +>assert : Symbol(assert, Decl(es3defaultAliasQuoted_file0.ts, 2, 1)) +>value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 4, 31)) if (!value) throw new Error("Assertion failed!"); ->value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31)) +>value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 4, 31)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -24,7 +23,7 @@ import {Foo, default as assert} from "./es3defaultAliasQuoted_file0"; assert(Foo.CONSTANT === "Foo"); >assert : Symbol(assert, Decl(es3defaultAliasQuoted_file1.ts, 0, 12)) ->Foo.CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18)) +>Foo.CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 0, 18)) >Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file1.ts, 0, 8)) ->CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18)) +>CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 0, 18)) diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.types b/tests/baselines/reference/es3defaultAliasIsQuoted.types index b0412359660..2a57d9d211f 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.types +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3defaultAliasQuoted_file0.ts === - export class Foo { >Foo : Foo diff --git a/tests/baselines/reference/es5-amd.js b/tests/baselines/reference/es5-amd.js index ebfc5ee12d1..23314c78e1f 100644 --- a/tests/baselines/reference/es5-amd.js +++ b/tests/baselines/reference/es5-amd.js @@ -1,5 +1,4 @@ //// [es5-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-amd.symbols b/tests/baselines/reference/es5-amd.symbols index 33ed9bc6423..21bf381ee8d 100644 --- a/tests/baselines/reference/es5-amd.symbols +++ b/tests/baselines/reference/es5-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-amd.ts === - class A >A : Symbol(A, Decl(es5-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-amd.types b/tests/baselines/reference/es5-amd.types index 62e47b91d10..e86ae793256 100644 --- a/tests/baselines/reference/es5-amd.types +++ b/tests/baselines/reference/es5-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-commonjs.js b/tests/baselines/reference/es5-commonjs.js index 8ebcfb01be6..e0f56796ef1 100644 --- a/tests/baselines/reference/es5-commonjs.js +++ b/tests/baselines/reference/es5-commonjs.js @@ -1,5 +1,4 @@ //// [es5-commonjs.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-commonjs.symbols b/tests/baselines/reference/es5-commonjs.symbols index a2319b14ce7..d043f9fddc0 100644 --- a/tests/baselines/reference/es5-commonjs.symbols +++ b/tests/baselines/reference/es5-commonjs.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs.ts === - export default class A >A : Symbol(A, Decl(es5-commonjs.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5-commonjs.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-commonjs.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-commonjs.types b/tests/baselines/reference/es5-commonjs.types index 06a14af7f4f..1b1fce6493c 100644 --- a/tests/baselines/reference/es5-commonjs.types +++ b/tests/baselines/reference/es5-commonjs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es5-commonjs2.js b/tests/baselines/reference/es5-commonjs2.js index 2c38edef6ae..ae196be9460 100644 --- a/tests/baselines/reference/es5-commonjs2.js +++ b/tests/baselines/reference/es5-commonjs2.js @@ -1,5 +1,4 @@ //// [es5-commonjs2.ts] - export default 1; diff --git a/tests/baselines/reference/es5-commonjs2.symbols b/tests/baselines/reference/es5-commonjs2.symbols index ee57f9ad5cd..c36026685dd 100644 --- a/tests/baselines/reference/es5-commonjs2.symbols +++ b/tests/baselines/reference/es5-commonjs2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs2.ts === - -No type information for this code.export default 1; +export default 1; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5-commonjs2.types b/tests/baselines/reference/es5-commonjs2.types index ee57f9ad5cd..c36026685dd 100644 --- a/tests/baselines/reference/es5-commonjs2.types +++ b/tests/baselines/reference/es5-commonjs2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs2.ts === - -No type information for this code.export default 1; +export default 1; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5-commonjs3.errors.txt b/tests/baselines/reference/es5-commonjs3.errors.txt index fddabf56fac..688e3dbd560 100644 --- a/tests/baselines/reference/es5-commonjs3.errors.txt +++ b/tests/baselines/reference/es5-commonjs3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5-commonjs3.ts(3,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. +tests/cases/compiler/es5-commonjs3.ts(2,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. ==== tests/cases/compiler/es5-commonjs3.ts (1 errors) ==== - export default "test"; export var __esModule = 1; ~~~~~~~~~~ diff --git a/tests/baselines/reference/es5-commonjs3.js b/tests/baselines/reference/es5-commonjs3.js index 15c11b189a3..8a310a108b4 100644 --- a/tests/baselines/reference/es5-commonjs3.js +++ b/tests/baselines/reference/es5-commonjs3.js @@ -1,5 +1,4 @@ //// [es5-commonjs3.ts] - export default "test"; export var __esModule = 1; diff --git a/tests/baselines/reference/es5-commonjs4.errors.txt b/tests/baselines/reference/es5-commonjs4.errors.txt index 9a901728cfb..b51c45d5c84 100644 --- a/tests/baselines/reference/es5-commonjs4.errors.txt +++ b/tests/baselines/reference/es5-commonjs4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5-commonjs4.ts(14,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. +tests/cases/compiler/es5-commonjs4.ts(13,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. ==== tests/cases/compiler/es5-commonjs4.ts (1 errors) ==== - export default class A { constructor () diff --git a/tests/baselines/reference/es5-commonjs4.js b/tests/baselines/reference/es5-commonjs4.js index d2530d1bdf2..23ca56e442d 100644 --- a/tests/baselines/reference/es5-commonjs4.js +++ b/tests/baselines/reference/es5-commonjs4.js @@ -1,5 +1,4 @@ //// [es5-commonjs4.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-commonjs5.js b/tests/baselines/reference/es5-commonjs5.js index bbc9bbba7c2..bd9af7daa0d 100644 --- a/tests/baselines/reference/es5-commonjs5.js +++ b/tests/baselines/reference/es5-commonjs5.js @@ -1,5 +1,4 @@ //// [es5-commonjs5.ts] - export default function () { return "test"; } diff --git a/tests/baselines/reference/es5-commonjs5.symbols b/tests/baselines/reference/es5-commonjs5.symbols index b134e216668..56991d9a003 100644 --- a/tests/baselines/reference/es5-commonjs5.symbols +++ b/tests/baselines/reference/es5-commonjs5.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/es5-commonjs5.ts === - -No type information for this code.export default function () { +export default function () { No type information for this code. return "test"; No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/es5-commonjs5.types b/tests/baselines/reference/es5-commonjs5.types index fb72fda8c11..29811be2f60 100644 --- a/tests/baselines/reference/es5-commonjs5.types +++ b/tests/baselines/reference/es5-commonjs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs5.ts === - export default function () { return "test"; >"test" : "test" diff --git a/tests/baselines/reference/es5-commonjs6.js b/tests/baselines/reference/es5-commonjs6.js index 87d2f7d62a6..3338cbdfa47 100644 --- a/tests/baselines/reference/es5-commonjs6.js +++ b/tests/baselines/reference/es5-commonjs6.js @@ -1,5 +1,4 @@ //// [es5-commonjs6.ts] - export default "test"; var __esModule = 1; diff --git a/tests/baselines/reference/es5-commonjs6.symbols b/tests/baselines/reference/es5-commonjs6.symbols index 7a2847e0f25..847ab3783f8 100644 --- a/tests/baselines/reference/es5-commonjs6.symbols +++ b/tests/baselines/reference/es5-commonjs6.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/es5-commonjs6.ts === - export default "test"; var __esModule = 1; ->__esModule : Symbol(__esModule, Decl(es5-commonjs6.ts, 2, 3)) +>__esModule : Symbol(__esModule, Decl(es5-commonjs6.ts, 1, 3)) diff --git a/tests/baselines/reference/es5-commonjs6.types b/tests/baselines/reference/es5-commonjs6.types index cabe84e8a69..73a16660a56 100644 --- a/tests/baselines/reference/es5-commonjs6.types +++ b/tests/baselines/reference/es5-commonjs6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs6.ts === - export default "test"; var __esModule = 1; >__esModule : number diff --git a/tests/baselines/reference/es5-commonjs7.symbols b/tests/baselines/reference/es5-commonjs7.symbols index 14c4cc71376..0ac992e7db9 100644 --- a/tests/baselines/reference/es5-commonjs7.symbols +++ b/tests/baselines/reference/es5-commonjs7.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/test.d.ts === - export default "test"; export var __esModule; ->__esModule : Symbol(__esModule, Decl(test.d.ts, 2, 10)) +>__esModule : Symbol(__esModule, Decl(test.d.ts, 1, 10)) diff --git a/tests/baselines/reference/es5-commonjs7.types b/tests/baselines/reference/es5-commonjs7.types index e2236a61c7b..60d9f9b6c62 100644 --- a/tests/baselines/reference/es5-commonjs7.types +++ b/tests/baselines/reference/es5-commonjs7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test.d.ts === - export default "test"; export var __esModule; >__esModule : any diff --git a/tests/baselines/reference/es5-commonjs8.symbols b/tests/baselines/reference/es5-commonjs8.symbols index 93041cc8b7f..78ffb413249 100644 --- a/tests/baselines/reference/es5-commonjs8.symbols +++ b/tests/baselines/reference/es5-commonjs8.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/es5-commonjs8.ts === - export default "test"; export var __esModule = 1; ->__esModule : Symbol(__esModule, Decl(es5-commonjs8.ts, 2, 10)) +>__esModule : Symbol(__esModule, Decl(es5-commonjs8.ts, 1, 10)) diff --git a/tests/baselines/reference/es5-commonjs8.types b/tests/baselines/reference/es5-commonjs8.types index be206bf5162..0d2196ffb96 100644 --- a/tests/baselines/reference/es5-commonjs8.types +++ b/tests/baselines/reference/es5-commonjs8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs8.ts === - export default "test"; export var __esModule = 1; >__esModule : number diff --git a/tests/baselines/reference/es5-declaration-amd.js b/tests/baselines/reference/es5-declaration-amd.js index 32c9690dc4e..618553ec0cf 100644 --- a/tests/baselines/reference/es5-declaration-amd.js +++ b/tests/baselines/reference/es5-declaration-amd.js @@ -1,5 +1,4 @@ //// [es5-declaration-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-declaration-amd.symbols b/tests/baselines/reference/es5-declaration-amd.symbols index 0df2ad428f0..37e7857600c 100644 --- a/tests/baselines/reference/es5-declaration-amd.symbols +++ b/tests/baselines/reference/es5-declaration-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-declaration-amd.ts === - class A >A : Symbol(A, Decl(es5-declaration-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-declaration-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-declaration-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-declaration-amd.types b/tests/baselines/reference/es5-declaration-amd.types index ca5422fd739..a71b0c39dcc 100644 --- a/tests/baselines/reference/es5-declaration-amd.types +++ b/tests/baselines/reference/es5-declaration-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-declaration-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-souremap-amd.js b/tests/baselines/reference/es5-souremap-amd.js index b957f605e7c..a4ac83a37af 100644 --- a/tests/baselines/reference/es5-souremap-amd.js +++ b/tests/baselines/reference/es5-souremap-amd.js @@ -1,5 +1,4 @@ //// [es5-souremap-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-souremap-amd.js.map b/tests/baselines/reference/es5-souremap-amd.js.map index 4c7e152e95b..111d19c26fc 100644 --- a/tests/baselines/reference/es5-souremap-amd.js.map +++ b/tests/baselines/reference/es5-souremap-amd.js.map @@ -1,2 +1,2 @@ //// [es5-souremap-amd.js.map] -{"version":3,"file":"es5-souremap-amd.js","sourceRoot":"","sources":["es5-souremap-amd.ts"],"names":[],"mappings":"AACA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file +{"version":3,"file":"es5-souremap-amd.js","sourceRoot":"","sources":["es5-souremap-amd.ts"],"names":[],"mappings":"AAAA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file diff --git a/tests/baselines/reference/es5-souremap-amd.sourcemap.txt b/tests/baselines/reference/es5-souremap-amd.sourcemap.txt index fc573856f9c..b57cfc57715 100644 --- a/tests/baselines/reference/es5-souremap-amd.sourcemap.txt +++ b/tests/baselines/reference/es5-souremap-amd.sourcemap.txt @@ -11,9 +11,8 @@ sourceFile:es5-souremap-amd.ts >>>var A = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ @@ -21,7 +20,7 @@ sourceFile:es5-souremap-amd.ts 1->class A >{ > -1->Emitted(2, 5) Source(4, 5) + SourceIndex(0) +1->Emitted(2, 5) Source(3, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -32,8 +31,8 @@ sourceFile:es5-souremap-amd.ts > > 2 > } -1->Emitted(3, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(3, 6) Source(7, 6) + SourceIndex(0) +1->Emitted(3, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(3, 6) Source(6, 6) + SourceIndex(0) --- >>> A.prototype.B = function () { 1->^^^^ @@ -44,9 +43,9 @@ sourceFile:es5-souremap-amd.ts > public 2 > B 3 > -1->Emitted(4, 5) Source(9, 12) + SourceIndex(0) -2 >Emitted(4, 18) Source(9, 13) + SourceIndex(0) -3 >Emitted(4, 21) Source(9, 5) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 12) + SourceIndex(0) +2 >Emitted(4, 18) Source(8, 13) + SourceIndex(0) +3 >Emitted(4, 21) Source(8, 5) + SourceIndex(0) --- >>> return 42; 1 >^^^^^^^^ @@ -61,11 +60,11 @@ sourceFile:es5-souremap-amd.ts 3 > 4 > 42 5 > ; -1 >Emitted(5, 9) Source(11, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(11, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(11, 16) + SourceIndex(0) -4 >Emitted(5, 18) Source(11, 18) + SourceIndex(0) -5 >Emitted(5, 19) Source(11, 19) + SourceIndex(0) +1 >Emitted(5, 9) Source(10, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) +4 >Emitted(5, 18) Source(10, 18) + SourceIndex(0) +5 >Emitted(5, 19) Source(10, 19) + SourceIndex(0) --- >>> }; 1 >^^^^ @@ -74,8 +73,8 @@ sourceFile:es5-souremap-amd.ts 1 > > 2 > } -1 >Emitted(6, 5) Source(12, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(12, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) --- >>> return A; 1->^^^^ @@ -83,8 +82,8 @@ sourceFile:es5-souremap-amd.ts 1-> > 2 > } -1->Emitted(7, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(7, 13) Source(13, 2) + SourceIndex(0) +1->Emitted(7, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(7, 13) Source(12, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -107,9 +106,9 @@ sourceFile:es5-souremap-amd.ts > return 42; > } > } -1 >Emitted(8, 1) Source(13, 1) + SourceIndex(0) -2 >Emitted(8, 2) Source(13, 2) + SourceIndex(0) -3 >Emitted(8, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(8, 6) Source(13, 2) + SourceIndex(0) +1 >Emitted(8, 1) Source(12, 1) + SourceIndex(0) +2 >Emitted(8, 2) Source(12, 2) + SourceIndex(0) +3 >Emitted(8, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(8, 6) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=es5-souremap-amd.js.map \ No newline at end of file diff --git a/tests/baselines/reference/es5-souremap-amd.symbols b/tests/baselines/reference/es5-souremap-amd.symbols index c725434096d..7ea1fbe96d8 100644 --- a/tests/baselines/reference/es5-souremap-amd.symbols +++ b/tests/baselines/reference/es5-souremap-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-souremap-amd.ts === - class A >A : Symbol(A, Decl(es5-souremap-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-souremap-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-souremap-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-souremap-amd.types b/tests/baselines/reference/es5-souremap-amd.types index d96f15b8d0e..01359011456 100644 --- a/tests/baselines/reference/es5-souremap-amd.types +++ b/tests/baselines/reference/es5-souremap-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-souremap-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-system.js b/tests/baselines/reference/es5-system.js index 1d59a05dcfa..4a62c429840 100644 --- a/tests/baselines/reference/es5-system.js +++ b/tests/baselines/reference/es5-system.js @@ -1,5 +1,4 @@ //// [es5-system.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-system.symbols b/tests/baselines/reference/es5-system.symbols index f2c4b38aba2..fe2c279a1e0 100644 --- a/tests/baselines/reference/es5-system.symbols +++ b/tests/baselines/reference/es5-system.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system.ts === - export default class A >A : Symbol(A, Decl(es5-system.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5-system.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-system.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-system.types b/tests/baselines/reference/es5-system.types index fa6d471dbf7..79fbcc06725 100644 --- a/tests/baselines/reference/es5-system.types +++ b/tests/baselines/reference/es5-system.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es5-system2.js b/tests/baselines/reference/es5-system2.js index 39b5e5daca2..4d793326b9b 100644 --- a/tests/baselines/reference/es5-system2.js +++ b/tests/baselines/reference/es5-system2.js @@ -1,5 +1,4 @@ //// [es5-system2.ts] - export var __esModule = 1; //// [es5-system2.js] diff --git a/tests/baselines/reference/es5-system2.symbols b/tests/baselines/reference/es5-system2.symbols index 2c8779b730b..b15352701df 100644 --- a/tests/baselines/reference/es5-system2.symbols +++ b/tests/baselines/reference/es5-system2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system2.ts === - export var __esModule = 1; ->__esModule : Symbol(__esModule, Decl(es5-system2.ts, 1, 10)) +>__esModule : Symbol(__esModule, Decl(es5-system2.ts, 0, 10)) diff --git a/tests/baselines/reference/es5-system2.types b/tests/baselines/reference/es5-system2.types index e67258a8732..43c5425e04a 100644 --- a/tests/baselines/reference/es5-system2.types +++ b/tests/baselines/reference/es5-system2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system2.ts === - export var __esModule = 1; >__esModule : number >1 : 1 diff --git a/tests/baselines/reference/es5-umd.js b/tests/baselines/reference/es5-umd.js index f98d5cde719..9ade8c259c0 100644 --- a/tests/baselines/reference/es5-umd.js +++ b/tests/baselines/reference/es5-umd.js @@ -1,5 +1,4 @@ //// [es5-umd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-umd.symbols b/tests/baselines/reference/es5-umd.symbols index 73dd7ebbe5b..3e14419f4da 100644 --- a/tests/baselines/reference/es5-umd.symbols +++ b/tests/baselines/reference/es5-umd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd.ts === - class A >A : Symbol(A, Decl(es5-umd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-umd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd.types b/tests/baselines/reference/es5-umd.types index dcee52664cc..c64d920298c 100644 --- a/tests/baselines/reference/es5-umd.types +++ b/tests/baselines/reference/es5-umd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-umd2.js b/tests/baselines/reference/es5-umd2.js index b55422ca7b1..335c0efa925 100644 --- a/tests/baselines/reference/es5-umd2.js +++ b/tests/baselines/reference/es5-umd2.js @@ -1,5 +1,4 @@ //// [es5-umd2.ts] - export class A { constructor () diff --git a/tests/baselines/reference/es5-umd2.symbols b/tests/baselines/reference/es5-umd2.symbols index f017c6b72db..9f2cda79925 100644 --- a/tests/baselines/reference/es5-umd2.symbols +++ b/tests/baselines/reference/es5-umd2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd2.ts === - export class A >A : Symbol(A, Decl(es5-umd2.ts, 0, 0)) { @@ -9,7 +8,7 @@ export class A } public B() ->B : Symbol(A.B, Decl(es5-umd2.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd2.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd2.types b/tests/baselines/reference/es5-umd2.types index 2c24088c4a0..65ed5cca171 100644 --- a/tests/baselines/reference/es5-umd2.types +++ b/tests/baselines/reference/es5-umd2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd2.ts === - export class A >A : A { diff --git a/tests/baselines/reference/es5-umd3.js b/tests/baselines/reference/es5-umd3.js index 37b19ece1ac..48f9971bdd1 100644 --- a/tests/baselines/reference/es5-umd3.js +++ b/tests/baselines/reference/es5-umd3.js @@ -1,5 +1,4 @@ //// [es5-umd3.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-umd3.symbols b/tests/baselines/reference/es5-umd3.symbols index ca0203b029c..96cca79de29 100644 --- a/tests/baselines/reference/es5-umd3.symbols +++ b/tests/baselines/reference/es5-umd3.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd3.ts === - export default class A >A : Symbol(A, Decl(es5-umd3.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5-umd3.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd3.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd3.types b/tests/baselines/reference/es5-umd3.types index bb4cc91af50..235bb0af631 100644 --- a/tests/baselines/reference/es5-umd3.types +++ b/tests/baselines/reference/es5-umd3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd3.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es5-umd4.js b/tests/baselines/reference/es5-umd4.js index ea3cba50ac0..71fdcc6f9b9 100644 --- a/tests/baselines/reference/es5-umd4.js +++ b/tests/baselines/reference/es5-umd4.js @@ -1,5 +1,4 @@ //// [es5-umd4.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-umd4.symbols b/tests/baselines/reference/es5-umd4.symbols index 790c8cccb97..3fd42895e51 100644 --- a/tests/baselines/reference/es5-umd4.symbols +++ b/tests/baselines/reference/es5-umd4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd4.ts === - class A >A : Symbol(A, Decl(es5-umd4.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-umd4.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd4.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd4.types b/tests/baselines/reference/es5-umd4.types index 4ce47c9e4de..d2e38a12cc8 100644 --- a/tests/baselines/reference/es5-umd4.types +++ b/tests/baselines/reference/es5-umd4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd4.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration.js index 25a1db0a25f..39fc9336e91 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration.ts] - export default class C { method() { } } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols index 8aaa8a4e532..2c536fa6862 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration.ts === - export default class C { >C : Symbol(C, Decl(es5ExportDefaultClassDeclaration.ts, 0, 0)) method() { } ->method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration.ts, 1, 24)) +>method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration.ts, 0, 24)) } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration.types index 34fb87fcbb2..b7514b80bf2 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration.ts === - export default class C { >C : C diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js index 931eab75c72..fae48029e6b 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration2.ts] - export default class { method() { } } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols index 05947d5a557..ceec038d5fc 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration2.ts === - export default class { method() { } ->method : Symbol(default.method, Decl(es5ExportDefaultClassDeclaration2.ts, 1, 22)) +>method : Symbol(default.method, Decl(es5ExportDefaultClassDeclaration2.ts, 0, 22)) } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types index e4c7a59e0e7..6ab8ee26948 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration2.ts === - export default class { method() { } >method : () => void diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js index 927536114ef..5c256022032 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration3.ts] - var before: C = new C(); export default class C { diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols index d5c8243161b..de2492da457 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts === - var before: C = new C(); ->before : Symbol(before, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 3)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) +>before : Symbol(before, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 3)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) export default class C { ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) method(): C { ->method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration3.ts, 3, 24)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) +>method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration3.ts, 2, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) return new C(); ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) } } var after: C = new C(); ->after : Symbol(after, Decl(es5ExportDefaultClassDeclaration3.ts, 9, 3)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) +>after : Symbol(after, Decl(es5ExportDefaultClassDeclaration3.ts, 8, 3)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) var t: typeof C = C; ->t : Symbol(t, Decl(es5ExportDefaultClassDeclaration3.ts, 11, 3)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 1, 24)) +>t : Symbol(t, Decl(es5ExportDefaultClassDeclaration3.ts, 10, 3)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types index 1ed302ac45e..325a0b97918 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts === - var before: C = new C(); >before : C >C : C diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js index 118367dd111..c82c96c48ce 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration4.ts] - declare module "foo" { export var before: C; diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols index 15faf638ca1..12afdf653ea 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration4.ts === - declare module "foo" { export var before: C; ->before : Symbol(before, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 14)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>before : Symbol(before, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 14)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) export default class C { ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) method(): C; ->method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration4.ts, 4, 28)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration4.ts, 3, 28)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) } export var after: C; ->after : Symbol(after, Decl(es5ExportDefaultClassDeclaration4.ts, 8, 14)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>after : Symbol(after, Decl(es5ExportDefaultClassDeclaration4.ts, 7, 14)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) export var t: typeof C; ->t : Symbol(t, Decl(es5ExportDefaultClassDeclaration4.ts, 10, 14)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>t : Symbol(t, Decl(es5ExportDefaultClassDeclaration4.ts, 9, 14)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types index de27b4b5fb0..12a8c0b4a49 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration4.ts === - declare module "foo" { export var before: C; >before : C diff --git a/tests/baselines/reference/es5ExportDefaultExpression.js b/tests/baselines/reference/es5ExportDefaultExpression.js index 0821543134c..3db562da647 100644 --- a/tests/baselines/reference/es5ExportDefaultExpression.js +++ b/tests/baselines/reference/es5ExportDefaultExpression.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultExpression.ts] - export default (1 + 2); diff --git a/tests/baselines/reference/es5ExportDefaultExpression.symbols b/tests/baselines/reference/es5ExportDefaultExpression.symbols index 3f9f11e283a..65b2419bac9 100644 --- a/tests/baselines/reference/es5ExportDefaultExpression.symbols +++ b/tests/baselines/reference/es5ExportDefaultExpression.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultExpression.ts === - -No type information for this code.export default (1 + 2); +export default (1 + 2); No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5ExportDefaultExpression.types b/tests/baselines/reference/es5ExportDefaultExpression.types index db4d3a3abfd..0184a5e56ae 100644 --- a/tests/baselines/reference/es5ExportDefaultExpression.types +++ b/tests/baselines/reference/es5ExportDefaultExpression.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultExpression.ts === - export default (1 + 2); >(1 + 2) : number >1 + 2 : number diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js index 068a966faa2..d834f345e50 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration.ts] - export default function f() { } diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols index 6c80a2532e3..5e99f510090 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : Symbol(f, Decl(es5ExportDefaultFunctionDeclaration.ts, 0, 0)) diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types index 446bd8e2a31..ee42d7200ec 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : () => void diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js index ab44c4cb584..28002494c54 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration2.ts] - export default function () { } diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols index 1b9f9d26151..133d9b73dd4 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types index 1b9f9d26151..133d9b73dd4 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js index c4bbcd4373e..c4f70ae45f4 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration3.ts] - var before: typeof func = func(); export default function func(): typeof func { diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols index 921a3304e01..644bf9e3013 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration3.ts === - var before: typeof func = func(); ->before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 3)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 3)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) export default function func(): typeof func { ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) return func; ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) } var after: typeof func = func(); ->after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration3.ts, 7, 3)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration3.ts, 6, 3)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types index d3a8ff92b2f..7d8f15719ca 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration3.ts === - var before: typeof func = func(); >before : () => typeof func >func : () => typeof func diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js index a8bdc7d79ef..0f553adc4bd 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration4.ts] - declare module "bar" { var before: typeof func; diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols index 940c095d11f..a694dba8abe 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration4.ts === - declare module "bar" { var before: typeof func; ->before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 7)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) +>before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 7)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) export default function func(): typeof func; ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) var after: typeof func; ->after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration4.ts, 6, 7)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) +>after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration4.ts, 5, 7)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) } diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types index 163311fbd14..22961c061de 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration4.ts === - declare module "bar" { var before: typeof func; >before : () => typeof func diff --git a/tests/baselines/reference/es5ExportDefaultIdentifier.js b/tests/baselines/reference/es5ExportDefaultIdentifier.js index d60fba590ac..49cddbf0677 100644 --- a/tests/baselines/reference/es5ExportDefaultIdentifier.js +++ b/tests/baselines/reference/es5ExportDefaultIdentifier.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultIdentifier.ts] - export function f() { } export default f; diff --git a/tests/baselines/reference/es5ExportDefaultIdentifier.symbols b/tests/baselines/reference/es5ExportDefaultIdentifier.symbols index 78b9a54947a..7ef0a0f65ce 100644 --- a/tests/baselines/reference/es5ExportDefaultIdentifier.symbols +++ b/tests/baselines/reference/es5ExportDefaultIdentifier.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultIdentifier.ts === - export function f() { } >f : Symbol(f, Decl(es5ExportDefaultIdentifier.ts, 0, 0)) diff --git a/tests/baselines/reference/es5ExportDefaultIdentifier.types b/tests/baselines/reference/es5ExportDefaultIdentifier.types index d57f7575070..860a934919d 100644 --- a/tests/baselines/reference/es5ExportDefaultIdentifier.types +++ b/tests/baselines/reference/es5ExportDefaultIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultIdentifier.ts === - export function f() { } >f : () => void diff --git a/tests/baselines/reference/es5ExportEquals.errors.txt b/tests/baselines/reference/es5ExportEquals.errors.txt index 89197aca632..4c573332136 100644 --- a/tests/baselines/reference/es5ExportEquals.errors.txt +++ b/tests/baselines/reference/es5ExportEquals.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5ExportEquals.ts(4,1): error TS2309: An export assignment cannot be used in a module with other exported elements. +tests/cases/compiler/es5ExportEquals.ts(3,1): error TS2309: An export assignment cannot be used in a module with other exported elements. ==== tests/cases/compiler/es5ExportEquals.ts (1 errors) ==== - export function f() { } export = f; diff --git a/tests/baselines/reference/es5ExportEquals.js b/tests/baselines/reference/es5ExportEquals.js index 3a1ae6fe242..fd9f2cc3e77 100644 --- a/tests/baselines/reference/es5ExportEquals.js +++ b/tests/baselines/reference/es5ExportEquals.js @@ -1,5 +1,4 @@ //// [es5ExportEquals.ts] - export function f() { } export = f; diff --git a/tests/baselines/reference/es5ExportEqualsDts.js b/tests/baselines/reference/es5ExportEqualsDts.js index bc083ca0756..b8d79efef94 100644 --- a/tests/baselines/reference/es5ExportEqualsDts.js +++ b/tests/baselines/reference/es5ExportEqualsDts.js @@ -1,5 +1,4 @@ //// [es5ExportEqualsDts.ts] - class A { foo() { var aVal: A.B; diff --git a/tests/baselines/reference/es5ExportEqualsDts.symbols b/tests/baselines/reference/es5ExportEqualsDts.symbols index 46bc29b58dd..0ea23053fd0 100644 --- a/tests/baselines/reference/es5ExportEqualsDts.symbols +++ b/tests/baselines/reference/es5ExportEqualsDts.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/es5ExportEqualsDts.ts === - class A { ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) foo() { ->foo : Symbol(A.foo, Decl(es5ExportEqualsDts.ts, 1, 9)) +>foo : Symbol(A.foo, Decl(es5ExportEqualsDts.ts, 0, 9)) var aVal: A.B; ->aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 3, 11)) ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) ->B : Symbol(A.B, Decl(es5ExportEqualsDts.ts, 8, 10)) +>aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 2, 11)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) +>B : Symbol(A.B, Decl(es5ExportEqualsDts.ts, 7, 10)) return aVal; ->aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 3, 11)) +>aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 2, 11)) } } module A { ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) export interface B { } ->B : Symbol(B, Decl(es5ExportEqualsDts.ts, 8, 10)) +>B : Symbol(B, Decl(es5ExportEqualsDts.ts, 7, 10)) } export = A ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) diff --git a/tests/baselines/reference/es5ExportEqualsDts.types b/tests/baselines/reference/es5ExportEqualsDts.types index 265fda6c76c..100fc3fb93d 100644 --- a/tests/baselines/reference/es5ExportEqualsDts.types +++ b/tests/baselines/reference/es5ExportEqualsDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportEqualsDts.ts === - class A { >A : A diff --git a/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt b/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt index 936f381628d..be6bb246c90 100644 --- a/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt +++ b/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/es5ModuleInternalNamedImports.ts(22,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(23,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(24,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(25,5): error TS1194: Export declarations are not permitted in a namespace. @@ -5,15 +6,13 @@ tests/cases/compiler/es5ModuleInternalNamedImports.ts(26,5): error TS1194: Expor tests/cases/compiler/es5ModuleInternalNamedImports.ts(27,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(28,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(29,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(30,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(31,25): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(32,20): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(33,32): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(35,16): error TS2307: Cannot find module 'M3'. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(30,25): error TS1147: Import declarations in a namespace cannot reference a module. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(31,20): error TS1147: Import declarations in a namespace cannot reference a module. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(32,32): error TS1147: Import declarations in a namespace cannot reference a module. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(34,16): error TS2307: Cannot find module 'M3'. ==== tests/cases/compiler/es5ModuleInternalNamedImports.ts (12 errors) ==== - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es5ModuleInternalNamedImports.js b/tests/baselines/reference/es5ModuleInternalNamedImports.js index abc81b3dc94..74063c4348f 100644 --- a/tests/baselines/reference/es5ModuleInternalNamedImports.js +++ b/tests/baselines/reference/es5ModuleInternalNamedImports.js @@ -1,5 +1,4 @@ //// [es5ModuleInternalNamedImports.ts] - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es5andes6module.js b/tests/baselines/reference/es5andes6module.js index ae8c0ad87e2..bfa260eaa3c 100644 --- a/tests/baselines/reference/es5andes6module.js +++ b/tests/baselines/reference/es5andes6module.js @@ -1,5 +1,4 @@ //// [es5andes6module.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5andes6module.symbols b/tests/baselines/reference/es5andes6module.symbols index 3aef923de0a..a553c83fd2b 100644 --- a/tests/baselines/reference/es5andes6module.symbols +++ b/tests/baselines/reference/es5andes6module.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5andes6module.ts === - export default class A >A : Symbol(A, Decl(es5andes6module.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5andes6module.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5andes6module.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5andes6module.types b/tests/baselines/reference/es5andes6module.types index 44dba0eb28e..567b7674a45 100644 --- a/tests/baselines/reference/es5andes6module.types +++ b/tests/baselines/reference/es5andes6module.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5andes6module.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es6-amd.js b/tests/baselines/reference/es6-amd.js index b09f074e59f..a6567c64cbe 100644 --- a/tests/baselines/reference/es6-amd.js +++ b/tests/baselines/reference/es6-amd.js @@ -1,5 +1,4 @@ //// [es6-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-amd.symbols b/tests/baselines/reference/es6-amd.symbols index fb9b1c57b27..a8176b5d2a3 100644 --- a/tests/baselines/reference/es6-amd.symbols +++ b/tests/baselines/reference/es6-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-amd.ts === - class A >A : Symbol(A, Decl(es6-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-amd.types b/tests/baselines/reference/es6-amd.types index 5ba03153627..c2e0d0d634f 100644 --- a/tests/baselines/reference/es6-amd.types +++ b/tests/baselines/reference/es6-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-declaration-amd.js b/tests/baselines/reference/es6-declaration-amd.js index b1f54086969..a019dd33d6e 100644 --- a/tests/baselines/reference/es6-declaration-amd.js +++ b/tests/baselines/reference/es6-declaration-amd.js @@ -1,5 +1,4 @@ //// [es6-declaration-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-declaration-amd.symbols b/tests/baselines/reference/es6-declaration-amd.symbols index 6811dfe793d..be7db99662a 100644 --- a/tests/baselines/reference/es6-declaration-amd.symbols +++ b/tests/baselines/reference/es6-declaration-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-declaration-amd.ts === - class A >A : Symbol(A, Decl(es6-declaration-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-declaration-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-declaration-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-declaration-amd.types b/tests/baselines/reference/es6-declaration-amd.types index 9568cedc0bd..3bbbf6bfe18 100644 --- a/tests/baselines/reference/es6-declaration-amd.types +++ b/tests/baselines/reference/es6-declaration-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-declaration-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-sourcemap-amd.js b/tests/baselines/reference/es6-sourcemap-amd.js index 106726c0f2c..864c1c512fc 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.js +++ b/tests/baselines/reference/es6-sourcemap-amd.js @@ -1,5 +1,4 @@ //// [es6-sourcemap-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-sourcemap-amd.js.map b/tests/baselines/reference/es6-sourcemap-amd.js.map index d5229e3a28c..0b8d7530c24 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.js.map +++ b/tests/baselines/reference/es6-sourcemap-amd.js.map @@ -1,2 +1,2 @@ //// [es6-sourcemap-amd.js.map] -{"version":3,"file":"es6-sourcemap-amd.js","sourceRoot":"","sources":["es6-sourcemap-amd.ts"],"names":[],"mappings":"AACA;IAEI;IAGA,CAAC;IAEM,CAAC;QAEJ,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;CACJ"} \ No newline at end of file +{"version":3,"file":"es6-sourcemap-amd.js","sourceRoot":"","sources":["es6-sourcemap-amd.ts"],"names":[],"mappings":"AAAA;IAEI;IAGA,CAAC;IAEM,CAAC;QAEJ,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;CACJ"} \ No newline at end of file diff --git a/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt b/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt index a01507e964b..fbc12ecf84b 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt +++ b/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt @@ -11,9 +11,8 @@ sourceFile:es6-sourcemap-amd.ts >>>class A { 1 > 2 >^^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> constructor() { 1->^^^^ @@ -21,7 +20,7 @@ sourceFile:es6-sourcemap-amd.ts 1->class A >{ > -1->Emitted(2, 5) Source(4, 5) + SourceIndex(0) +1->Emitted(2, 5) Source(3, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -32,8 +31,8 @@ sourceFile:es6-sourcemap-amd.ts > > 2 > } -1->Emitted(3, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(3, 6) Source(7, 6) + SourceIndex(0) +1->Emitted(3, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(3, 6) Source(6, 6) + SourceIndex(0) --- >>> B() { 1->^^^^ @@ -43,8 +42,8 @@ sourceFile:es6-sourcemap-amd.ts > > public 2 > B -1->Emitted(4, 5) Source(9, 12) + SourceIndex(0) -2 >Emitted(4, 6) Source(9, 13) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 12) + SourceIndex(0) +2 >Emitted(4, 6) Source(8, 13) + SourceIndex(0) --- >>> return 42; 1->^^^^^^^^ @@ -59,11 +58,11 @@ sourceFile:es6-sourcemap-amd.ts 3 > 4 > 42 5 > ; -1->Emitted(5, 9) Source(11, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(11, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(11, 16) + SourceIndex(0) -4 >Emitted(5, 18) Source(11, 18) + SourceIndex(0) -5 >Emitted(5, 19) Source(11, 19) + SourceIndex(0) +1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) +4 >Emitted(5, 18) Source(10, 18) + SourceIndex(0) +5 >Emitted(5, 19) Source(10, 19) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -71,14 +70,14 @@ sourceFile:es6-sourcemap-amd.ts 1 > > 2 > } -1 >Emitted(6, 5) Source(12, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(12, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(13, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=es6-sourcemap-amd.js.map \ No newline at end of file diff --git a/tests/baselines/reference/es6-sourcemap-amd.symbols b/tests/baselines/reference/es6-sourcemap-amd.symbols index e5f731234f3..2ca5f4fa6ac 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.symbols +++ b/tests/baselines/reference/es6-sourcemap-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-sourcemap-amd.ts === - class A >A : Symbol(A, Decl(es6-sourcemap-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-sourcemap-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-sourcemap-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-sourcemap-amd.types b/tests/baselines/reference/es6-sourcemap-amd.types index 6cbdc98df6f..c83f1f54e39 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.types +++ b/tests/baselines/reference/es6-sourcemap-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-sourcemap-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-umd.js b/tests/baselines/reference/es6-umd.js index af8159eeb3e..0caa8525bfb 100644 --- a/tests/baselines/reference/es6-umd.js +++ b/tests/baselines/reference/es6-umd.js @@ -1,5 +1,4 @@ //// [es6-umd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-umd.symbols b/tests/baselines/reference/es6-umd.symbols index 50584887fb3..986f63f826c 100644 --- a/tests/baselines/reference/es6-umd.symbols +++ b/tests/baselines/reference/es6-umd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd.ts === - class A >A : Symbol(A, Decl(es6-umd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-umd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-umd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-umd.types b/tests/baselines/reference/es6-umd.types index ed3932d2e2a..621eea8112c 100644 --- a/tests/baselines/reference/es6-umd.types +++ b/tests/baselines/reference/es6-umd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-umd2.js b/tests/baselines/reference/es6-umd2.js index c0707b869cc..dcccb24d511 100644 --- a/tests/baselines/reference/es6-umd2.js +++ b/tests/baselines/reference/es6-umd2.js @@ -1,5 +1,4 @@ //// [es6-umd2.ts] - export class A { constructor () diff --git a/tests/baselines/reference/es6-umd2.symbols b/tests/baselines/reference/es6-umd2.symbols index d998e4b68ee..e4a5c976a7e 100644 --- a/tests/baselines/reference/es6-umd2.symbols +++ b/tests/baselines/reference/es6-umd2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd2.ts === - export class A >A : Symbol(A, Decl(es6-umd2.ts, 0, 0)) { @@ -9,7 +8,7 @@ export class A } public B() ->B : Symbol(A.B, Decl(es6-umd2.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-umd2.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-umd2.types b/tests/baselines/reference/es6-umd2.types index 395f136add8..9ab3dedd7cf 100644 --- a/tests/baselines/reference/es6-umd2.types +++ b/tests/baselines/reference/es6-umd2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd2.ts === - export class A >A : A { diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.js b/tests/baselines/reference/es6ClassSuperCodegenBug.js index 1945726d218..95b4adb25ee 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.js +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.js @@ -1,5 +1,4 @@ //// [es6ClassSuperCodegenBug.ts] - class A { constructor(str1:string, str2:string) {} } diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols index bb500a1d2c2..d520ec3ceb1 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/es6ClassSuperCodegenBug.ts === - class A { >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0)) constructor(str1:string, str2:string) {} ->str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 2, 13)) ->str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 2, 25)) +>str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 1, 13)) +>str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 1, 25)) } class B extends A { ->B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 3, 1)) +>B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 2, 1)) >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0)) constructor() { diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.types b/tests/baselines/reference/es6ClassSuperCodegenBug.types index d98b1fea451..b454ead3f6f 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.types +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ClassSuperCodegenBug.ts === - class A { >A : A diff --git a/tests/baselines/reference/es6ExportAll.js b/tests/baselines/reference/es6ExportAll.js index afa07c39d8f..9149bcfa2e7 100644 --- a/tests/baselines/reference/es6ExportAll.js +++ b/tests/baselines/reference/es6ExportAll.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAll.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportAll.symbols b/tests/baselines/reference/es6ExportAll.symbols index c2a575f5e5c..d0890d99e3d 100644 --- a/tests/baselines/reference/es6ExportAll.symbols +++ b/tests/baselines/reference/es6ExportAll.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportAll.types b/tests/baselines/reference/es6ExportAll.types index b6a7056fd4a..e3a012135e0 100644 --- a/tests/baselines/reference/es6ExportAll.types +++ b/tests/baselines/reference/es6ExportAll.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportAllInEs5.js b/tests/baselines/reference/es6ExportAllInEs5.js index 91910ba2616..6b1b1c82354 100644 --- a/tests/baselines/reference/es6ExportAllInEs5.js +++ b/tests/baselines/reference/es6ExportAllInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAllInEs5.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportAllInEs5.symbols b/tests/baselines/reference/es6ExportAllInEs5.symbols index 26d47f63af3..2a2ad20f22f 100644 --- a/tests/baselines/reference/es6ExportAllInEs5.symbols +++ b/tests/baselines/reference/es6ExportAllInEs5.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportAllInEs5.types b/tests/baselines/reference/es6ExportAllInEs5.types index fc3daf6685c..fc465785493 100644 --- a/tests/baselines/reference/es6ExportAllInEs5.types +++ b/tests/baselines/reference/es6ExportAllInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportAssignment.errors.txt b/tests/baselines/reference/es6ExportAssignment.errors.txt index be5ad734c86..55a150f47ad 100644 --- a/tests/baselines/reference/es6ExportAssignment.errors.txt +++ b/tests/baselines/reference/es6ExportAssignment.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es6ExportAssignment.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/es6ExportAssignment.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/es6ExportAssignment.ts (1 errors) ==== - var a = 10; export = a; ~~~~~~~~~~~ diff --git a/tests/baselines/reference/es6ExportAssignment.js b/tests/baselines/reference/es6ExportAssignment.js index 4a4e0368bb7..3d0198901ef 100644 --- a/tests/baselines/reference/es6ExportAssignment.js +++ b/tests/baselines/reference/es6ExportAssignment.js @@ -1,5 +1,4 @@ //// [es6ExportAssignment.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ExportAssignment2.errors.txt b/tests/baselines/reference/es6ExportAssignment2.errors.txt index 490d5867591..9065f9ba6ce 100644 --- a/tests/baselines/reference/es6ExportAssignment2.errors.txt +++ b/tests/baselines/reference/es6ExportAssignment2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/a.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 10; export = a; // Error: export = not allowed in ES6 ~~~~~~~~~~~ diff --git a/tests/baselines/reference/es6ExportAssignment2.js b/tests/baselines/reference/es6ExportAssignment2.js index f038f71d494..531c9e5a5ba 100644 --- a/tests/baselines/reference/es6ExportAssignment2.js +++ b/tests/baselines/reference/es6ExportAssignment2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAssignment2.ts] //// //// [a.ts] - var a = 10; export = a; // Error: export = not allowed in ES6 diff --git a/tests/baselines/reference/es6ExportAssignment3.js b/tests/baselines/reference/es6ExportAssignment3.js index 1a25ee94023..5a2cd208a5a 100644 --- a/tests/baselines/reference/es6ExportAssignment3.js +++ b/tests/baselines/reference/es6ExportAssignment3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAssignment3.ts] //// //// [a.d.ts] - declare var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/es6ExportAssignment3.symbols b/tests/baselines/reference/es6ExportAssignment3.symbols index 73346cdc4b8..40a7a1108da 100644 --- a/tests/baselines/reference/es6ExportAssignment3.symbols +++ b/tests/baselines/reference/es6ExportAssignment3.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) === tests/cases/compiler/b.ts === import * as a from "a"; diff --git a/tests/baselines/reference/es6ExportAssignment3.types b/tests/baselines/reference/es6ExportAssignment3.types index 84f896c301d..91901d68c48 100644 --- a/tests/baselines/reference/es6ExportAssignment3.types +++ b/tests/baselines/reference/es6ExportAssignment3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; >a : number diff --git a/tests/baselines/reference/es6ExportAssignment4.js b/tests/baselines/reference/es6ExportAssignment4.js index a06aa4d49de..656dcc0729f 100644 --- a/tests/baselines/reference/es6ExportAssignment4.js +++ b/tests/baselines/reference/es6ExportAssignment4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAssignment4.ts] //// //// [modules.d.ts] - declare module "a" { var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/es6ExportAssignment4.symbols b/tests/baselines/reference/es6ExportAssignment4.symbols index 42d4a9d009f..099892c706e 100644 --- a/tests/baselines/reference/es6ExportAssignment4.symbols +++ b/tests/baselines/reference/es6ExportAssignment4.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) } === tests/cases/compiler/b.ts === diff --git a/tests/baselines/reference/es6ExportAssignment4.types b/tests/baselines/reference/es6ExportAssignment4.types index c32bc14ec90..e42fadc2944 100644 --- a/tests/baselines/reference/es6ExportAssignment4.types +++ b/tests/baselines/reference/es6ExportAssignment4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; >a : number diff --git a/tests/baselines/reference/es6ExportClause.js b/tests/baselines/reference/es6ExportClause.js index 742a39e1324..3c4a17f3812 100644 --- a/tests/baselines/reference/es6ExportClause.js +++ b/tests/baselines/reference/es6ExportClause.js @@ -1,5 +1,4 @@ //// [server.ts] - class c { } interface i { diff --git a/tests/baselines/reference/es6ExportClause.symbols b/tests/baselines/reference/es6ExportClause.symbols index 1bacedec76c..428b0b4448b 100644 --- a/tests/baselines/reference/es6ExportClause.symbols +++ b/tests/baselines/reference/es6ExportClause.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/server.ts === - class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 3)) +>x : Symbol(x, Decl(server.ts, 7, 3)) module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 11)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 11)) } export { c }; ->c : Symbol(c, Decl(server.ts, 11, 8)) +>c : Symbol(c, Decl(server.ts, 10, 8)) export { c as c2 }; ->c : Symbol(c2, Decl(server.ts, 12, 8)) ->c2 : Symbol(c2, Decl(server.ts, 12, 8)) +>c : Symbol(c2, Decl(server.ts, 11, 8)) +>c2 : Symbol(c2, Decl(server.ts, 11, 8)) export { i, m as instantiatedModule }; ->i : Symbol(i, Decl(server.ts, 13, 8)) ->m : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) ->instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) +>i : Symbol(i, Decl(server.ts, 12, 8)) +>m : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) +>instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) export { uninstantiated }; ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 14, 8)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 13, 8)) export { x }; ->x : Symbol(x, Decl(server.ts, 15, 8)) +>x : Symbol(x, Decl(server.ts, 14, 8)) diff --git a/tests/baselines/reference/es6ExportClause.types b/tests/baselines/reference/es6ExportClause.types index 22e5f9c0e0d..8cc9187cff0 100644 --- a/tests/baselines/reference/es6ExportClause.types +++ b/tests/baselines/reference/es6ExportClause.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { >c : c } diff --git a/tests/baselines/reference/es6ExportClauseInEs5.js b/tests/baselines/reference/es6ExportClauseInEs5.js index 3d3625aad18..d6d44fe8b2b 100644 --- a/tests/baselines/reference/es6ExportClauseInEs5.js +++ b/tests/baselines/reference/es6ExportClauseInEs5.js @@ -1,5 +1,4 @@ //// [server.ts] - class c { } interface i { diff --git a/tests/baselines/reference/es6ExportClauseInEs5.symbols b/tests/baselines/reference/es6ExportClauseInEs5.symbols index 1bacedec76c..428b0b4448b 100644 --- a/tests/baselines/reference/es6ExportClauseInEs5.symbols +++ b/tests/baselines/reference/es6ExportClauseInEs5.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/server.ts === - class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 3)) +>x : Symbol(x, Decl(server.ts, 7, 3)) module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 11)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 11)) } export { c }; ->c : Symbol(c, Decl(server.ts, 11, 8)) +>c : Symbol(c, Decl(server.ts, 10, 8)) export { c as c2 }; ->c : Symbol(c2, Decl(server.ts, 12, 8)) ->c2 : Symbol(c2, Decl(server.ts, 12, 8)) +>c : Symbol(c2, Decl(server.ts, 11, 8)) +>c2 : Symbol(c2, Decl(server.ts, 11, 8)) export { i, m as instantiatedModule }; ->i : Symbol(i, Decl(server.ts, 13, 8)) ->m : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) ->instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) +>i : Symbol(i, Decl(server.ts, 12, 8)) +>m : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) +>instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) export { uninstantiated }; ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 14, 8)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 13, 8)) export { x }; ->x : Symbol(x, Decl(server.ts, 15, 8)) +>x : Symbol(x, Decl(server.ts, 14, 8)) diff --git a/tests/baselines/reference/es6ExportClauseInEs5.types b/tests/baselines/reference/es6ExportClauseInEs5.types index 22e5f9c0e0d..8cc9187cff0 100644 --- a/tests/baselines/reference/es6ExportClauseInEs5.types +++ b/tests/baselines/reference/es6ExportClauseInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { >c : c } diff --git a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js index d8aa8e607e3..8d76534e677 100644 --- a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js +++ b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js @@ -1,5 +1,4 @@ //// [server.ts] - var foo = 2; foo = 3; diff --git a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols index 6f8dbb01ec5..27c40ea5bbe 100644 --- a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols +++ b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols @@ -1,40 +1,39 @@ === tests/cases/compiler/server.ts === - var foo = 2; ->foo : Symbol(foo, Decl(server.ts, 1, 3)) +>foo : Symbol(foo, Decl(server.ts, 0, 3)) foo = 3; ->foo : Symbol(foo, Decl(server.ts, 1, 3)) +>foo : Symbol(foo, Decl(server.ts, 0, 3)) var baz = 3; ->baz : Symbol(baz, Decl(server.ts, 4, 3)) +>baz : Symbol(baz, Decl(server.ts, 3, 3)) baz = 4; ->baz : Symbol(baz, Decl(server.ts, 4, 3)) +>baz : Symbol(baz, Decl(server.ts, 3, 3)) var buzz = 10; ->buzz : Symbol(buzz, Decl(server.ts, 7, 3)) +>buzz : Symbol(buzz, Decl(server.ts, 6, 3)) buzz += 3; ->buzz : Symbol(buzz, Decl(server.ts, 7, 3)) +>buzz : Symbol(buzz, Decl(server.ts, 6, 3)) var bizz = 8; ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) bizz++; // compiles to exports.bizz = bizz += 1 ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) bizz--; // similarly ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) ++bizz; // compiles to exports.bizz = ++bizz ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) export { foo, baz, baz as quux, buzz, bizz }; ->foo : Symbol(foo, Decl(server.ts, 15, 8)) ->baz : Symbol(baz, Decl(server.ts, 15, 13)) ->baz : Symbol(quux, Decl(server.ts, 15, 18)) ->quux : Symbol(quux, Decl(server.ts, 15, 18)) ->buzz : Symbol(buzz, Decl(server.ts, 15, 31)) ->bizz : Symbol(bizz, Decl(server.ts, 15, 37)) +>foo : Symbol(foo, Decl(server.ts, 14, 8)) +>baz : Symbol(baz, Decl(server.ts, 14, 13)) +>baz : Symbol(quux, Decl(server.ts, 14, 18)) +>quux : Symbol(quux, Decl(server.ts, 14, 18)) +>buzz : Symbol(buzz, Decl(server.ts, 14, 31)) +>bizz : Symbol(bizz, Decl(server.ts, 14, 37)) diff --git a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types index f846063c7ef..ece6e7b90a8 100644 --- a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types +++ b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - var foo = 2; >foo : number >2 : 2 diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js index ccdd32d99c0..9fda5910fcc 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportClauseWithoutModuleSpecifier.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols index 731a0fdcc30..5103e803104 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types index 748f731f918..abb1c3b69e2 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js index ecfccd5d843..d9b31f4edbb 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportClauseWithoutModuleSpecifierInEs5.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols index c8e279e65bf..a69f038d077 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types index 496717c3a85..b407d9b16f5 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration.js b/tests/baselines/reference/es6ExportDefaultClassDeclaration.js index 8162d6813b6..0d1de55af63 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration.js +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultClassDeclaration.ts] - export default class C { method() { } } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols b/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols index 3e5ce34c7d7..e7676339df6 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration.ts === - export default class C { >C : Symbol(C, Decl(es6ExportDefaultClassDeclaration.ts, 0, 0)) method() { } ->method : Symbol(C.method, Decl(es6ExportDefaultClassDeclaration.ts, 1, 24)) +>method : Symbol(C.method, Decl(es6ExportDefaultClassDeclaration.ts, 0, 24)) } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration.types b/tests/baselines/reference/es6ExportDefaultClassDeclaration.types index 59e74fc1257..2cd5c9e4d31 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration.types +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration.ts === - export default class C { >C : C diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js index e2f8524fb06..3b7cb476dfd 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultClassDeclaration2.ts] - export default class { method() { } } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols index a52c754c581..6bd008ce2df 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration2.ts === - export default class { method() { } ->method : Symbol(default.method, Decl(es6ExportDefaultClassDeclaration2.ts, 1, 22)) +>method : Symbol(default.method, Decl(es6ExportDefaultClassDeclaration2.ts, 0, 22)) } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types index 513cacf05e4..2723190fddf 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration2.ts === - export default class { method() { } >method : () => void diff --git a/tests/baselines/reference/es6ExportDefaultExpression.js b/tests/baselines/reference/es6ExportDefaultExpression.js index 100182b9f28..ce6dcd71b90 100644 --- a/tests/baselines/reference/es6ExportDefaultExpression.js +++ b/tests/baselines/reference/es6ExportDefaultExpression.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultExpression.ts] - export default (1 + 2); diff --git a/tests/baselines/reference/es6ExportDefaultExpression.symbols b/tests/baselines/reference/es6ExportDefaultExpression.symbols index f80acc12900..b5d3549a1f6 100644 --- a/tests/baselines/reference/es6ExportDefaultExpression.symbols +++ b/tests/baselines/reference/es6ExportDefaultExpression.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultExpression.ts === - -No type information for this code.export default (1 + 2); +export default (1 + 2); No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportDefaultExpression.types b/tests/baselines/reference/es6ExportDefaultExpression.types index 1e6a38482b6..8228dba1cf5 100644 --- a/tests/baselines/reference/es6ExportDefaultExpression.types +++ b/tests/baselines/reference/es6ExportDefaultExpression.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultExpression.ts === - export default (1 + 2); >(1 + 2) : number >1 + 2 : number diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js index a30c8d71039..7ddb52cd6d0 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultFunctionDeclaration.ts] - export default function f() { } diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols index 4050ac97545..47cc63cdd5d 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : Symbol(f, Decl(es6ExportDefaultFunctionDeclaration.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types index 6179bde9613..cf6c5ca5b46 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : () => void diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js index 46ed72dd236..dc2713f8f14 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultFunctionDeclaration2.ts] - export default function () { } diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols index 3cb2fc9b1cd..4021dbdc49a 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types index 3cb2fc9b1cd..4021dbdc49a 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportDefaultIdentifier.js b/tests/baselines/reference/es6ExportDefaultIdentifier.js index 1fd3a38ff8d..8f2e39fa171 100644 --- a/tests/baselines/reference/es6ExportDefaultIdentifier.js +++ b/tests/baselines/reference/es6ExportDefaultIdentifier.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultIdentifier.ts] - export function f() { } export default f; diff --git a/tests/baselines/reference/es6ExportDefaultIdentifier.symbols b/tests/baselines/reference/es6ExportDefaultIdentifier.symbols index 29b932aaeda..96e7a601922 100644 --- a/tests/baselines/reference/es6ExportDefaultIdentifier.symbols +++ b/tests/baselines/reference/es6ExportDefaultIdentifier.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultIdentifier.ts === - export function f() { } >f : Symbol(f, Decl(es6ExportDefaultIdentifier.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ExportDefaultIdentifier.types b/tests/baselines/reference/es6ExportDefaultIdentifier.types index 81dc168efd0..2e6264fd250 100644 --- a/tests/baselines/reference/es6ExportDefaultIdentifier.types +++ b/tests/baselines/reference/es6ExportDefaultIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultIdentifier.ts === - export function f() { } >f : () => void diff --git a/tests/baselines/reference/es6ExportEquals.errors.txt b/tests/baselines/reference/es6ExportEquals.errors.txt index 8a6c6ceef37..fa6e8519918 100644 --- a/tests/baselines/reference/es6ExportEquals.errors.txt +++ b/tests/baselines/reference/es6ExportEquals.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/es6ExportEquals.ts(4,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. -tests/cases/compiler/es6ExportEquals.ts(4,1): error TS2309: An export assignment cannot be used in a module with other exported elements. +tests/cases/compiler/es6ExportEquals.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/es6ExportEquals.ts(3,1): error TS2309: An export assignment cannot be used in a module with other exported elements. ==== tests/cases/compiler/es6ExportEquals.ts (2 errors) ==== - export function f() { } export = f; diff --git a/tests/baselines/reference/es6ExportEquals.js b/tests/baselines/reference/es6ExportEquals.js index e4cf13758ff..99cae1c5a73 100644 --- a/tests/baselines/reference/es6ExportEquals.js +++ b/tests/baselines/reference/es6ExportEquals.js @@ -1,5 +1,4 @@ //// [es6ExportEquals.ts] - export function f() { } export = f; diff --git a/tests/baselines/reference/es6ExportEqualsInterop.errors.txt b/tests/baselines/reference/es6ExportEqualsInterop.errors.txt index be9aaf35fc4..4a9f7dcb506 100644 --- a/tests/baselines/reference/es6ExportEqualsInterop.errors.txt +++ b/tests/baselines/reference/es6ExportEqualsInterop.errors.txt @@ -205,7 +205,6 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses !!! error TS2498: Module '"class-module"' uses 'export =' and cannot be used with 'export *'. ==== tests/cases/compiler/modules.d.ts (0 errors) ==== - declare module "interface" { interface Foo { x: number; diff --git a/tests/baselines/reference/es6ExportEqualsInterop.js b/tests/baselines/reference/es6ExportEqualsInterop.js index d1f8de5faa7..156587028dd 100644 --- a/tests/baselines/reference/es6ExportEqualsInterop.js +++ b/tests/baselines/reference/es6ExportEqualsInterop.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportEqualsInterop.ts] //// //// [modules.d.ts] - declare module "interface" { interface Foo { x: number; diff --git a/tests/baselines/reference/es6ImportDefaultBinding.js b/tests/baselines/reference/es6ImportDefaultBinding.js index 2798d025894..5629c9b8cdc 100644 --- a/tests/baselines/reference/es6ImportDefaultBinding.js +++ b/tests/baselines/reference/es6ImportDefaultBinding.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBinding.ts] //// //// [es6ImportDefaultBinding_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBinding.symbols b/tests/baselines/reference/es6ImportDefaultBinding.symbols index d1e76d7075a..66f05f9267e 100644 --- a/tests/baselines/reference/es6ImportDefaultBinding.symbols +++ b/tests/baselines/reference/es6ImportDefaultBinding.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBinding_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBinding_1.ts === import defaultBinding from "es6ImportDefaultBinding_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBinding.types b/tests/baselines/reference/es6ImportDefaultBinding.types index f538ee8127b..a93fa91f1c8 100644 --- a/tests/baselines/reference/es6ImportDefaultBinding.types +++ b/tests/baselines/reference/es6ImportDefaultBinding.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBinding_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingAmd.js b/tests/baselines/reference/es6ImportDefaultBindingAmd.js index 977b94f8790..d8a13efa2d6 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingAmd.js +++ b/tests/baselines/reference/es6ImportDefaultBindingAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingAmd.ts] //// //// [es6ImportDefaultBindingAmd_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols b/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols index cab731104bd..a370a729113 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBindingAmd_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBindingAmd_1.ts === import defaultBinding from "es6ImportDefaultBindingAmd_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBindingAmd.types b/tests/baselines/reference/es6ImportDefaultBindingAmd.types index 824c5568b17..8ce878a1c92 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingAmd.types +++ b/tests/baselines/reference/es6ImportDefaultBindingAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingAmd_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingDts.js b/tests/baselines/reference/es6ImportDefaultBindingDts.js index 94b824a3766..55df3a8e98e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingDts.js +++ b/tests/baselines/reference/es6ImportDefaultBindingDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingDts.ts] //// //// [server.ts] - class c { } export default c; diff --git a/tests/baselines/reference/es6ImportDefaultBindingDts.symbols b/tests/baselines/reference/es6ImportDefaultBindingDts.symbols index f25be3eacad..3465cdd318c 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingDts.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingDts.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { } >c : Symbol(c, Decl(server.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ImportDefaultBindingDts.types b/tests/baselines/reference/es6ImportDefaultBindingDts.types index 8543c6845b2..31d4904cf81 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingDts.types +++ b/tests/baselines/reference/es6ImportDefaultBindingDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { } >c : c diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js index 8335a1953de..bccb0a9dea4 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImport_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols index 5da138f6c62..b7e713f29d3 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 0, 10)) export default {}; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types index 0fba9c6390c..fb48d53778f 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt index 21f488e9ca5..86900c03bbe 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1_1.ts(11,27) ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1_0.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js index 755af6f4fdb..54a4d434606 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImport1_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt index c62ecb70c58..5649b5c2ed0 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1InEs5_1.ts(1 ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1InEs5_0.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js index 8eb76b487f8..46e52a43135 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImport1InEs5_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt index 97c66a17960..6acc3edc77e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt @@ -19,7 +19,6 @@ tests/cases/compiler/client.ts(12,12): error TS2323: Cannot redeclare exported v ==== tests/cases/compiler/server.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js index d72751c7610..02c093987d4 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.ts] //// //// [server.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt index 47e0cb347f3..57621079e29 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/client.ts(11,8): error TS1192: Module '"tests/cases/compile ==== tests/cases/compiler/server.ts (0 errors) ==== - export class a { } export class x { } export class m { } diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js index 5bf268709d3..0809a5278f0 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportDts.ts] //// //// [server.ts] - export class a { } export class x { } export class m { } diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt index e939398632c..b078d0abfe3 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/client.ts(11,27): error TS2305: Module '"tests/cases/compil ==== tests/cases/compiler/server.ts (0 errors) ==== - class a { } export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js index 307dcc92f46..cf0219ce1c7 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportDts1.ts] //// //// [server.ts] - class a { } export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt index 7c5080241f1..c6735211e6e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportInEs5_1.ts(11 ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportInEs5_0.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js index 2e9d8104a39..90875ff5878 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportInEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImportInEs5_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt index 859fe59b47f..57ef30e3c00 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/client.ts(12,12): error TS2323: Cannot redeclare exported v ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js index 77266084bda..756ae6a999b 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportWithExport.ts] //// //// [server.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt index eb28020ca9e..4cf81cfc804 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts(1, ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js index 2b24fda0755..4fbac48bd36 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts] - export var a = 10; //// [es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js index a732cf9ec0a..eb90b4882b0 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding1.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols index a62cdfec873..2eae4503db5 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts === import defaultBinding, * as nameSpaceBinding from "es6ImportDefaultBindingFollowedWithNamespaceBinding_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types index a97100c662c..4cc93acc6bb 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js index c1c41968934..a6217abb784 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols index 4262dd3c61b..dec550cc914 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1.ts === import defaultBinding, * as nameSpaceBinding from "./es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types index 18dc5efe226..dca293b535c 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt index f738abc9bc1..236c98d02f7 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/client.ts(1,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js index b82fb9aeee9..2e5ce8ebc0b 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.ts] //// //// [server.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt index 1fc12619017..ac986c63004 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/client.ts(1,8): error TS1192: Module '"tests/cases/compiler ==== tests/cases/compiler/server.ts (0 errors) ==== - export class a { } ==== tests/cases/compiler/client.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js index 8d033c69536..b153fb042eb 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.ts] //// //// [server.ts] - export class a { } //// [client.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js index c488db3e88e..41140c71646 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.ts] //// //// [server.ts] - class a { } export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols index 28f1e4cc4d7..655f5828a87 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class a { } >a : Symbol(a, Decl(server.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types index 990bae10af6..33cc7c15301 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class a { } >a : a diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt index f14af87315c..d3d0f1c1c6e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1. ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js index 0db21dfd064..5586054319a 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts] - export var a = 10; //// [es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt index d0eee527356..526bf9a03e0 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/client.ts(1,15): error TS1192: Module '"tests/cases/compile ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/client.ts (2 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js index 96720294a8a..ded9e2811a2 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.ts] //// //// [server.ts] - export var a = 10; //// [client.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt index 18f634d7b73..604b27fd9c2 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingInEs5_1.ts(1,8): error TS1192: Modul ==== tests/cases/compiler/es6ImportDefaultBindingInEs5_0.ts (0 errors) ==== - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingInEs5.js b/tests/baselines/reference/es6ImportDefaultBindingInEs5.js index f6ea8348118..165f58b9246 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingInEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingInEs5.ts] //// //// [es6ImportDefaultBindingInEs5_0.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt index 87311d3557c..d6235f446cf 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt @@ -4,7 +4,6 @@ tests/cases/compiler/es6ImportDefaultBindingMergeErrors_1.ts(8,8): error TS2300: ==== tests/cases/compiler/es6ImportDefaultBindingMergeErrors_0.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js index 4c51a54462d..85f3d34cd67 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js +++ b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingMergeErrors.ts] //// //// [es6ImportDefaultBindingMergeErrors_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt index 9d0e46ceb97..11c9c0af140 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty_1.ts(1,8): error T ==== tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty_1.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js index e294c08befa..0b233910696 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js +++ b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty.ts] //// //// [es6ImportDefaultBindingNoDefaultProperty_0.ts] - export var a = 10; //// [es6ImportDefaultBindingNoDefaultProperty_1.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt index 1bd24e84926..c39d34a2ef4 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/client.ts(3,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingWithExport.js b/tests/baselines/reference/es6ImportDefaultBindingWithExport.js index a9f760f1278..38b391ac6d3 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingWithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingWithExport.ts] //// //// [server.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt b/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt index fa0d9dc834a..37870a2a366 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt +++ b/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/client.ts(1,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. -tests/cases/compiler/server.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/server.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/client.ts (1 errors) ==== @@ -7,7 +7,6 @@ tests/cases/compiler/server.ts(3,1): error TS1203: Export assignment cannot be u ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. ==== tests/cases/compiler/server.ts (1 errors) ==== - var a = 10; export = a; ~~~~~~~~~~~ diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration.js b/tests/baselines/reference/es6ImportEqualsDeclaration.js index 5195bdc631b..1ca0e94cf8a 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration.js +++ b/tests/baselines/reference/es6ImportEqualsDeclaration.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportEqualsDeclaration.ts] //// //// [server.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration2.js b/tests/baselines/reference/es6ImportEqualsDeclaration2.js index c7a009a17cf..cc6d33a9afa 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration2.js +++ b/tests/baselines/reference/es6ImportEqualsDeclaration2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportEqualsDeclaration2.ts] //// //// [server.d.ts] - declare module "other" { export class C { } } diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols b/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols index a7c556f5be0..d751025baf3 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols +++ b/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/server.d.ts === - declare module "other" { export class C { } ->C : Symbol(C, Decl(server.d.ts, 1, 24)) +>C : Symbol(C, Decl(server.d.ts, 0, 24)) } declare module "server" { import events = require("other"); // Ambient declaration, no error expected. ->events : Symbol(events, Decl(server.d.ts, 5, 25)) +>events : Symbol(events, Decl(server.d.ts, 4, 25)) module S { ->S : Symbol(S, Decl(server.d.ts, 6, 37)) +>S : Symbol(S, Decl(server.d.ts, 5, 37)) export var a: number; ->a : Symbol(a, Decl(server.d.ts, 9, 18)) +>a : Symbol(a, Decl(server.d.ts, 8, 18)) } export = S; // Ambient declaration, no error expected. ->S : Symbol(S, Decl(server.d.ts, 6, 37)) +>S : Symbol(S, Decl(server.d.ts, 5, 37)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration2.types b/tests/baselines/reference/es6ImportEqualsDeclaration2.types index a483d10f25c..93d47a330d6 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration2.types +++ b/tests/baselines/reference/es6ImportEqualsDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.d.ts === - declare module "other" { export class C { } >C : C diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.js b/tests/baselines/reference/es6ImportNameSpaceImport.js index b5296d15f9b..c9013259e8e 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.js +++ b/tests/baselines/reference/es6ImportNameSpaceImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImport.ts] //// //// [es6ImportNameSpaceImport_0.ts] - export var a = 10; //// [es6ImportNameSpaceImport_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.symbols b/tests/baselines/reference/es6ImportNameSpaceImport.symbols index add2b792d49..12bd21cf3df 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImport.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNameSpaceImport_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNameSpaceImport_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNameSpaceImport_1.ts === import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; @@ -9,9 +8,9 @@ import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; var x = nameSpaceBinding.a; >x : Symbol(x, Decl(es6ImportNameSpaceImport_1.ts, 1, 3)) ->nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) +>nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 0, 10)) >nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImport_1.ts, 0, 6)) ->a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 0, 10)) import * as nameSpaceBinding2 from "./es6ImportNameSpaceImport_0"; // elide this >nameSpaceBinding2 : Symbol(nameSpaceBinding2, Decl(es6ImportNameSpaceImport_1.ts, 2, 6)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.types b/tests/baselines/reference/es6ImportNameSpaceImport.types index 6b73fb90bce..51d1ae69a32 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.types +++ b/tests/baselines/reference/es6ImportNameSpaceImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImport_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportAmd.js b/tests/baselines/reference/es6ImportNameSpaceImportAmd.js index 200f49a2986..44a0635f7a2 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportAmd.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportAmd.ts] //// //// [es6ImportNameSpaceImportAmd_0.ts] - export var a = 10; //// [es6ImportNameSpaceImportAmd_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols b/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols index 24c67cd6f47..0a8fa16191d 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNameSpaceImportAmd_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImportAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportAmd_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNameSpaceImportAmd_1.ts === import * as nameSpaceBinding from "es6ImportNameSpaceImportAmd_0"; @@ -9,9 +8,9 @@ import * as nameSpaceBinding from "es6ImportNameSpaceImportAmd_0"; var x = nameSpaceBinding.a; >x : Symbol(x, Decl(es6ImportNameSpaceImportAmd_1.ts, 1, 3)) ->nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 1, 10)) +>nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 0, 10)) >nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImportAmd_1.ts, 0, 6)) ->a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 1, 10)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 0, 10)) import * as nameSpaceBinding2 from "es6ImportNameSpaceImportAmd_0"; // elide this >nameSpaceBinding2 : Symbol(nameSpaceBinding2, Decl(es6ImportNameSpaceImportAmd_1.ts, 2, 6)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImportAmd.types b/tests/baselines/reference/es6ImportNameSpaceImportAmd.types index 96cd4e603ea..f11f90fd6a8 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportAmd.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImportAmd_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportDts.js b/tests/baselines/reference/es6ImportNameSpaceImportDts.js index cae90885ce2..d57f881de91 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportDts.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportDts.ts] //// //// [server.ts] - export class c { }; //// [client.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols b/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols index 5f6fea374be..6426da0933c 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { }; >c : Symbol(c, Decl(server.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImportDts.types b/tests/baselines/reference/es6ImportNameSpaceImportDts.types index e49f3ace57a..5a1916191ff 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportDts.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { }; >c : c diff --git a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js index ee00df9a2cc..1eced8142cb 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportInEs5.ts] //// //// [es6ImportNameSpaceImportInEs5_0.ts] - export var a = 10; //// [es6ImportNameSpaceImportInEs5_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols index 7be619dcc7e..7239d5f46fd 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNameSpaceImportInEs5_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNameSpaceImportInEs5_1.ts === import * as nameSpaceBinding from "./es6ImportNameSpaceImportInEs5_0"; @@ -9,9 +8,9 @@ import * as nameSpaceBinding from "./es6ImportNameSpaceImportInEs5_0"; var x = nameSpaceBinding.a; >x : Symbol(x, Decl(es6ImportNameSpaceImportInEs5_1.ts, 1, 3)) ->nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 1, 10)) +>nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 0, 10)) >nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImportInEs5_1.ts, 0, 6)) ->a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 1, 10)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 0, 10)) import * as nameSpaceBinding2 from "./es6ImportNameSpaceImportInEs5_0"; // elide this >nameSpaceBinding2 : Symbol(nameSpaceBinding2, Decl(es6ImportNameSpaceImportInEs5_1.ts, 2, 6)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types index 81971078849..647535cf51b 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImportInEs5_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt index de9ba696532..e73061ef152 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt +++ b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt @@ -4,7 +4,6 @@ tests/cases/compiler/es6ImportNameSpaceImportMergeErrors_1.ts(7,8): error TS2440 ==== tests/cases/compiler/es6ImportNameSpaceImportMergeErrors_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportNameSpaceImportMergeErrors_1.ts (3 errors) ==== diff --git a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js index 39594102007..1a41e265e7d 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportMergeErrors.ts] //// //// [es6ImportNameSpaceImportMergeErrors_0.ts] - export var a = 10; //// [es6ImportNameSpaceImportMergeErrors_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js index 0276c44f8ab..760a4a96828 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports.ts] //// //// [es6ImportNameSpaceImportNoNamedExports_0.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols index 8767c1a4add..f37e1f7014b 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 0, 3)) export = a; ->a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 0, 3)) === tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports_1.ts === import * as nameSpaceBinding from "./es6ImportNameSpaceImportNoNamedExports_0"; // error diff --git a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types index 041100c7678..f8f97e01ef3 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt index 901556e73bd..eac060e5968 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/client.ts(3,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/client.ts (2 errors) ==== diff --git a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js index 3c8b40f550e..57aa0cf0c05 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportWithExport.ts] //// //// [server.ts] - export var a = 10; //// [client.ts] diff --git a/tests/baselines/reference/es6ImportNamedImport.js b/tests/baselines/reference/es6ImportNamedImport.js index a9fcb861ec5..92e56660cc7 100644 --- a/tests/baselines/reference/es6ImportNamedImport.js +++ b/tests/baselines/reference/es6ImportNamedImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImport.ts] //// //// [es6ImportNamedImport_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImport.symbols b/tests/baselines/reference/es6ImportNamedImport.symbols index 0d30db6113f..10a1b79be54 100644 --- a/tests/baselines/reference/es6ImportNamedImport.symbols +++ b/tests/baselines/reference/es6ImportNamedImport.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es6ImportNamedImport_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportNamedImport_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportNamedImport_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportNamedImport_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 0, 10)) export var a1 = 10; ->a1 : Symbol(a1, Decl(es6ImportNamedImport_0.ts, 4, 10)) +>a1 : Symbol(a1, Decl(es6ImportNamedImport_0.ts, 3, 10)) export var x1 = 10; ->x1 : Symbol(x1, Decl(es6ImportNamedImport_0.ts, 5, 10)) +>x1 : Symbol(x1, Decl(es6ImportNamedImport_0.ts, 4, 10)) export var z1 = 10; ->z1 : Symbol(z1, Decl(es6ImportNamedImport_0.ts, 6, 10)) +>z1 : Symbol(z1, Decl(es6ImportNamedImport_0.ts, 5, 10)) export var z2 = 10; ->z2 : Symbol(z2, Decl(es6ImportNamedImport_0.ts, 7, 10)) +>z2 : Symbol(z2, Decl(es6ImportNamedImport_0.ts, 6, 10)) export var aaaa = 10; ->aaaa : Symbol(aaaa, Decl(es6ImportNamedImport_0.ts, 8, 10)) +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImport_0.ts, 7, 10)) === tests/cases/compiler/es6ImportNamedImport_1.ts === import { } from "./es6ImportNamedImport_0"; diff --git a/tests/baselines/reference/es6ImportNamedImport.types b/tests/baselines/reference/es6ImportNamedImport.types index 0ac3789c5e0..1172e1e0850 100644 --- a/tests/baselines/reference/es6ImportNamedImport.types +++ b/tests/baselines/reference/es6ImportNamedImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImport_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportAmd.js b/tests/baselines/reference/es6ImportNamedImportAmd.js index bd6213f259f..8f1a7cb013b 100644 --- a/tests/baselines/reference/es6ImportNamedImportAmd.js +++ b/tests/baselines/reference/es6ImportNamedImportAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportAmd.ts] //// //// [es6ImportNamedImportAmd_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportAmd.symbols b/tests/baselines/reference/es6ImportNamedImportAmd.symbols index 2feaf603f40..1a50a0ccf95 100644 --- a/tests/baselines/reference/es6ImportNamedImportAmd.symbols +++ b/tests/baselines/reference/es6ImportNamedImportAmd.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es6ImportNamedImportAmd_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportNamedImportAmd_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportNamedImportAmd_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportNamedImportAmd_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 0, 10)) export var a1 = 10; ->a1 : Symbol(a1, Decl(es6ImportNamedImportAmd_0.ts, 4, 10)) +>a1 : Symbol(a1, Decl(es6ImportNamedImportAmd_0.ts, 3, 10)) export var x1 = 10; ->x1 : Symbol(x1, Decl(es6ImportNamedImportAmd_0.ts, 5, 10)) +>x1 : Symbol(x1, Decl(es6ImportNamedImportAmd_0.ts, 4, 10)) export var z1 = 10; ->z1 : Symbol(z1, Decl(es6ImportNamedImportAmd_0.ts, 6, 10)) +>z1 : Symbol(z1, Decl(es6ImportNamedImportAmd_0.ts, 5, 10)) export var z2 = 10; ->z2 : Symbol(z2, Decl(es6ImportNamedImportAmd_0.ts, 7, 10)) +>z2 : Symbol(z2, Decl(es6ImportNamedImportAmd_0.ts, 6, 10)) export var aaaa = 10; ->aaaa : Symbol(aaaa, Decl(es6ImportNamedImportAmd_0.ts, 8, 10)) +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImportAmd_0.ts, 7, 10)) === tests/cases/compiler/es6ImportNamedImportAmd_1.ts === import { } from "es6ImportNamedImportAmd_0"; diff --git a/tests/baselines/reference/es6ImportNamedImportAmd.types b/tests/baselines/reference/es6ImportNamedImportAmd.types index 897187a5a0d..a987fda53fd 100644 --- a/tests/baselines/reference/es6ImportNamedImportAmd.types +++ b/tests/baselines/reference/es6ImportNamedImportAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportAmd_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportDts.js b/tests/baselines/reference/es6ImportNamedImportDts.js index d68ffd794a7..0ce09d4b180 100644 --- a/tests/baselines/reference/es6ImportNamedImportDts.js +++ b/tests/baselines/reference/es6ImportNamedImportDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportDts.ts] //// //// [server.ts] - export class a { } export class a11 { } export class a12 { } diff --git a/tests/baselines/reference/es6ImportNamedImportDts.symbols b/tests/baselines/reference/es6ImportNamedImportDts.symbols index dab2e13d0f6..88e22bec1b5 100644 --- a/tests/baselines/reference/es6ImportNamedImportDts.symbols +++ b/tests/baselines/reference/es6ImportNamedImportDts.symbols @@ -1,46 +1,45 @@ === tests/cases/compiler/server.ts === - export class a { } >a : Symbol(a, Decl(server.ts, 0, 0)) export class a11 { } ->a11 : Symbol(a11, Decl(server.ts, 1, 18)) +>a11 : Symbol(a11, Decl(server.ts, 0, 18)) export class a12 { } ->a12 : Symbol(a12, Decl(server.ts, 2, 20)) +>a12 : Symbol(a12, Decl(server.ts, 1, 20)) export class x { } ->x : Symbol(x, Decl(server.ts, 3, 20)) +>x : Symbol(x, Decl(server.ts, 2, 20)) export class x11 { } ->x11 : Symbol(x11, Decl(server.ts, 4, 18)) +>x11 : Symbol(x11, Decl(server.ts, 3, 18)) export class m { } ->m : Symbol(m, Decl(server.ts, 5, 20)) +>m : Symbol(m, Decl(server.ts, 4, 20)) export class a1 { } ->a1 : Symbol(a1, Decl(server.ts, 6, 18)) +>a1 : Symbol(a1, Decl(server.ts, 5, 18)) export class x1 { } ->x1 : Symbol(x1, Decl(server.ts, 7, 19)) +>x1 : Symbol(x1, Decl(server.ts, 6, 19)) export class a111 { } ->a111 : Symbol(a111, Decl(server.ts, 8, 19)) +>a111 : Symbol(a111, Decl(server.ts, 7, 19)) export class x111 { } ->x111 : Symbol(x111, Decl(server.ts, 9, 21)) +>x111 : Symbol(x111, Decl(server.ts, 8, 21)) export class z1 { } ->z1 : Symbol(z1, Decl(server.ts, 10, 21)) +>z1 : Symbol(z1, Decl(server.ts, 9, 21)) export class z2 { } ->z2 : Symbol(z2, Decl(server.ts, 11, 19)) +>z2 : Symbol(z2, Decl(server.ts, 10, 19)) export class aaaa { } ->aaaa : Symbol(aaaa, Decl(server.ts, 12, 19)) +>aaaa : Symbol(aaaa, Decl(server.ts, 11, 19)) export class aaaa1 { } ->aaaa1 : Symbol(aaaa1, Decl(server.ts, 13, 21)) +>aaaa1 : Symbol(aaaa1, Decl(server.ts, 12, 21)) === tests/cases/compiler/client.ts === import { } from "./server"; diff --git a/tests/baselines/reference/es6ImportNamedImportDts.types b/tests/baselines/reference/es6ImportNamedImportDts.types index 9aba1012117..d30d147bf80 100644 --- a/tests/baselines/reference/es6ImportNamedImportDts.types +++ b/tests/baselines/reference/es6ImportNamedImportDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class a { } >a : a diff --git a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt index cb0a5caff8d..34a33ccab97 100644 --- a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt @@ -1,20 +1,19 @@ -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,10): error TS2300: Duplicate identifier 'yield'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,23): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,10): error TS1003: Identifier expected. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,10): error TS2300: Duplicate identifier 'default'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,25): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,19): error TS1003: Identifier expected. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,19): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(1,10): error TS2300: Duplicate identifier 'yield'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(1,23): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,10): error TS1003: Identifier expected. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,10): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,25): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,19): error TS1003: Identifier expected. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,19): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,34): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,21): error TS2300: Duplicate identifier 'yield'. tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,34): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,21): error TS2300: Duplicate identifier 'yield'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,34): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(6,21): error TS1003: Identifier expected. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(6,21): error TS2300: Duplicate identifier 'default'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(6,36): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,21): error TS1003: Identifier expected. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,21): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,36): error TS2307: Cannot find module 'somemodule'. ==== tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts (13 errors) ==== - import { yield } from "somemodule"; // Allowed ~~~~~ !!! error TS2300: Duplicate identifier 'yield'. diff --git a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js index 8db7fcd6f9c..5e22dd98bd4 100644 --- a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js +++ b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js @@ -1,5 +1,4 @@ //// [es6ImportNamedImportIdentifiersParsing.ts] - import { yield } from "somemodule"; // Allowed import { default } from "somemodule"; // Error - as this is keyword that is not allowed as identifier import { yield as default } from "somemodule"; // error to use default as binding name diff --git a/tests/baselines/reference/es6ImportNamedImportInEs5.js b/tests/baselines/reference/es6ImportNamedImportInEs5.js index 9e025dca61b..8cedfa664a8 100644 --- a/tests/baselines/reference/es6ImportNamedImportInEs5.js +++ b/tests/baselines/reference/es6ImportNamedImportInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportInEs5.ts] //// //// [es6ImportNamedImportInEs5_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportInEs5.symbols b/tests/baselines/reference/es6ImportNamedImportInEs5.symbols index f9e949e7efb..b08aff200fb 100644 --- a/tests/baselines/reference/es6ImportNamedImportInEs5.symbols +++ b/tests/baselines/reference/es6ImportNamedImportInEs5.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es6ImportNamedImportInEs5_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportNamedImportInEs5_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportNamedImportInEs5_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportNamedImportInEs5_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 0, 10)) export var a1 = 10; ->a1 : Symbol(a1, Decl(es6ImportNamedImportInEs5_0.ts, 4, 10)) +>a1 : Symbol(a1, Decl(es6ImportNamedImportInEs5_0.ts, 3, 10)) export var x1 = 10; ->x1 : Symbol(x1, Decl(es6ImportNamedImportInEs5_0.ts, 5, 10)) +>x1 : Symbol(x1, Decl(es6ImportNamedImportInEs5_0.ts, 4, 10)) export var z1 = 10; ->z1 : Symbol(z1, Decl(es6ImportNamedImportInEs5_0.ts, 6, 10)) +>z1 : Symbol(z1, Decl(es6ImportNamedImportInEs5_0.ts, 5, 10)) export var z2 = 10; ->z2 : Symbol(z2, Decl(es6ImportNamedImportInEs5_0.ts, 7, 10)) +>z2 : Symbol(z2, Decl(es6ImportNamedImportInEs5_0.ts, 6, 10)) export var aaaa = 10; ->aaaa : Symbol(aaaa, Decl(es6ImportNamedImportInEs5_0.ts, 8, 10)) +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImportInEs5_0.ts, 7, 10)) === tests/cases/compiler/es6ImportNamedImportInEs5_1.ts === import { } from "./es6ImportNamedImportInEs5_0"; diff --git a/tests/baselines/reference/es6ImportNamedImportInEs5.types b/tests/baselines/reference/es6ImportNamedImportInEs5.types index f2af5280fc2..3a907acc11e 100644 --- a/tests/baselines/reference/es6ImportNamedImportInEs5.types +++ b/tests/baselines/reference/es6ImportNamedImportInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportInEs5_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js index d64b517c50f..54dc4ca750c 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportInExportAssignment.ts] //// //// [es6ImportNamedImportInExportAssignment_0.ts] - export var a = 10; //// [es6ImportNamedImportInExportAssignment_1.ts] diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols index 03ca0740f08..c9344acad95 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNamedImportInExportAssignment_1.ts === import { a } from "./es6ImportNamedImportInExportAssignment_0"; diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types index 5b550c77a00..1d6027e4b5b 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js index 38cda17bd7e..3acd2f9c4a0 100644 --- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js +++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportInIndirectExportAssignment.ts] //// //// [es6ImportNamedImportInIndirectExportAssignment_0.ts] - export module a { export class c { } diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols index 77b93c3ef00..257ea8c8c85 100644 --- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols +++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportNamedImportInIndirectExportAssignment_0.ts === - export module a { >a : Symbol(a, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 1, 17)) +>c : Symbol(c, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 0, 17)) } } diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types index d4dd62aacb2..f875f79aca9 100644 --- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types +++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportInIndirectExportAssignment_0.ts === - export module a { >a : typeof a diff --git a/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt b/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt index 0646e4f2fd6..c607e2e1652 100644 --- a/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt @@ -5,7 +5,6 @@ tests/cases/compiler/es6ImportNamedImportMergeErrors_1.ts(10,16): error TS2300: ==== tests/cases/compiler/es6ImportNamedImportMergeErrors_0.ts (0 errors) ==== - export var a = 10; export var x = a; export var z = a; diff --git a/tests/baselines/reference/es6ImportNamedImportMergeErrors.js b/tests/baselines/reference/es6ImportNamedImportMergeErrors.js index 261039bcc10..61b2cbf76b3 100644 --- a/tests/baselines/reference/es6ImportNamedImportMergeErrors.js +++ b/tests/baselines/reference/es6ImportNamedImportMergeErrors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportMergeErrors.ts] //// //// [es6ImportNamedImportMergeErrors_0.ts] - export var a = 10; export var x = a; export var z = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt b/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt index 47a836fd422..31c8002f735 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/es6ImportNamedImport_1.ts(2,10): error TS2305: Module '"tes ==== tests/cases/compiler/es6ImportNamedImportNoExportMember_0.ts (0 errors) ==== - export var a = 10; export var x = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoExportMember.js b/tests/baselines/reference/es6ImportNamedImportNoExportMember.js index 4e78df34b6d..2c8e9fe5fec 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoExportMember.js +++ b/tests/baselines/reference/es6ImportNamedImportNoExportMember.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportNoExportMember.ts] //// //// [es6ImportNamedImportNoExportMember_0.ts] - export var a = 10; export var x = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt index e2cacba59e8..66fa2d217c2 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/es6ImportNamedImportNoNamedExports_1.ts(2,10): error TS2305 ==== tests/cases/compiler/es6ImportNamedImportNoNamedExports_0.ts (0 errors) ==== - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js index a02116b314d..ea0d398355e 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js +++ b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportNoNamedExports.ts] //// //// [es6ImportNamedImportNoNamedExports_0.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt b/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt index 585cc51fb92..aa89e2dc997 100644 --- a/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt @@ -15,7 +15,6 @@ tests/cases/compiler/es6ImportNamedImportParsingError_1.ts(4,20): error TS1005: ==== tests/cases/compiler/es6ImportNamedImportParsingError_0.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportParsingError.js b/tests/baselines/reference/es6ImportNamedImportParsingError.js index 81f141b3dd8..76f14f91ff2 100644 --- a/tests/baselines/reference/es6ImportNamedImportParsingError.js +++ b/tests/baselines/reference/es6ImportNamedImportParsingError.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportParsingError.ts] //// //// [es6ImportNamedImportParsingError_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt b/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt index 3b2d6b0cbd0..61e0d298349 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt @@ -23,7 +23,6 @@ tests/cases/compiler/client.ts(26,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportWithExport.js b/tests/baselines/reference/es6ImportNamedImportWithExport.js index 13e2d40144b..b864f86258e 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithExport.js +++ b/tests/baselines/reference/es6ImportNamedImportWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportWithExport.ts] //// //// [server.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js index 0aa3214e5d7..2a00feccd3b 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js +++ b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportWithTypesAndValues.ts] //// //// [server.ts] - export interface I { prop: string; } diff --git a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols index 5abd8c88867..2343f1be141 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols +++ b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/server.ts === - export interface I { >I : Symbol(I, Decl(server.ts, 0, 0)) prop: string; ->prop : Symbol(I.prop, Decl(server.ts, 1, 20)) +>prop : Symbol(I.prop, Decl(server.ts, 0, 20)) } export interface I2 { ->I2 : Symbol(I2, Decl(server.ts, 3, 1)) +>I2 : Symbol(I2, Decl(server.ts, 2, 1)) prop2: string; ->prop2 : Symbol(I2.prop2, Decl(server.ts, 4, 21)) +>prop2 : Symbol(I2.prop2, Decl(server.ts, 3, 21)) } export class C implements I { ->C : Symbol(C, Decl(server.ts, 6, 1)) +>C : Symbol(C, Decl(server.ts, 5, 1)) >I : Symbol(I, Decl(server.ts, 0, 0)) prop = "hello"; ->prop : Symbol(C.prop, Decl(server.ts, 7, 29)) +>prop : Symbol(C.prop, Decl(server.ts, 6, 29)) } export class C2 implements I2 { ->C2 : Symbol(C2, Decl(server.ts, 9, 1)) ->I2 : Symbol(I2, Decl(server.ts, 3, 1)) +>C2 : Symbol(C2, Decl(server.ts, 8, 1)) +>I2 : Symbol(I2, Decl(server.ts, 2, 1)) prop2 = "world"; ->prop2 : Symbol(C2.prop2, Decl(server.ts, 10, 31)) +>prop2 : Symbol(C2.prop2, Decl(server.ts, 9, 31)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types index 11c6caf3dbe..43e98cb1ad8 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types +++ b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export interface I { >I : I diff --git a/tests/baselines/reference/es6ImportParseErrors.errors.txt b/tests/baselines/reference/es6ImportParseErrors.errors.txt index d1e1cb7d00d..671692cd121 100644 --- a/tests/baselines/reference/es6ImportParseErrors.errors.txt +++ b/tests/baselines/reference/es6ImportParseErrors.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es6ImportParseErrors.ts(2,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/es6ImportParseErrors.ts(1,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/es6ImportParseErrors.ts (1 errors) ==== - import 10; ~~~~~~ !!! error TS1128: Declaration or statement expected. \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportParseErrors.js b/tests/baselines/reference/es6ImportParseErrors.js index a42d65fbc9d..faa7bc161ce 100644 --- a/tests/baselines/reference/es6ImportParseErrors.js +++ b/tests/baselines/reference/es6ImportParseErrors.js @@ -1,5 +1,4 @@ //// [es6ImportParseErrors.ts] - import 10; //// [es6ImportParseErrors.js] diff --git a/tests/baselines/reference/es6ImportWithoutFromClause.js b/tests/baselines/reference/es6ImportWithoutFromClause.js index cc8509baade..f23ac0381c7 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClause.js +++ b/tests/baselines/reference/es6ImportWithoutFromClause.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClause.ts] //// //// [es6ImportWithoutFromClause_0.ts] - export var a = 10; //// [es6ImportWithoutFromClause_1.ts] diff --git a/tests/baselines/reference/es6ImportWithoutFromClause.symbols b/tests/baselines/reference/es6ImportWithoutFromClause.symbols index 31eafdf655c..4298fc77724 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClause.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClause.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportWithoutFromClause_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportWithoutFromClause_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportWithoutFromClause_0.ts, 0, 10)) === tests/cases/compiler/es6ImportWithoutFromClause_1.ts === import "es6ImportWithoutFromClause_0"; diff --git a/tests/baselines/reference/es6ImportWithoutFromClause.types b/tests/baselines/reference/es6ImportWithoutFromClause.types index cd49acbcd0f..bf017cb2fc0 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClause.types +++ b/tests/baselines/reference/es6ImportWithoutFromClause.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClause_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js index d83ba9370ee..f6134e3d899 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseAmd.ts] //// //// [es6ImportWithoutFromClauseAmd_0.ts] - export var a = 10; //// [es6ImportWithoutFromClauseAmd_1.ts] diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols index 36e1e79f0b5..3e92e2f00d1 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportWithoutFromClauseAmd_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportWithoutFromClauseAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportWithoutFromClauseAmd_0.ts, 0, 10)) === tests/cases/compiler/es6ImportWithoutFromClauseAmd_1.ts === export var b = 10; diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types index 5099dee908b..0638e4e5e69 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types +++ b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseAmd_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js index b11e2ea9a07..d0a96043465 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseInEs5.ts] //// //// [es6ImportWithoutFromClauseInEs5_0.ts] - export var a = 10; //// [es6ImportWithoutFromClauseInEs5_1.ts] diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols index c8db6eff479..b1701aa7208 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportWithoutFromClauseInEs5_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportWithoutFromClauseInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportWithoutFromClauseInEs5_0.ts, 0, 10)) === tests/cases/compiler/es6ImportWithoutFromClauseInEs5_1.ts === import "es6ImportWithoutFromClauseInEs5_0"; diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types index 1e90de3223f..02eacf11b25 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types +++ b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseInEs5_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js index 51bb0f3338d..8fa9de0a98d 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseNonInstantiatedModule.ts] //// //// [es6ImportWithoutFromClauseNonInstantiatedModule_0.ts] - export interface i { } diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols index 0fe8e68e1a3..e520bede4d8 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseNonInstantiatedModule_0.ts === - export interface i { >i : Symbol(i, Decl(es6ImportWithoutFromClauseNonInstantiatedModule_0.ts, 0, 0)) } diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types index 2be3f67f1e9..62eff2856a3 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types +++ b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseNonInstantiatedModule_0.ts === - export interface i { >i : i } diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt index da865698e56..cda3f545070 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/client.ts(1,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/client.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js index 99214d2a2c6..755ec99d258 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseWithExport.ts] //// //// [server.ts] - export var a = 10; //// [client.ts] diff --git a/tests/baselines/reference/es6MemberScoping.errors.txt b/tests/baselines/reference/es6MemberScoping.errors.txt index 07788a68648..db5c5b3edf0 100644 --- a/tests/baselines/reference/es6MemberScoping.errors.txt +++ b/tests/baselines/reference/es6MemberScoping.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/es6MemberScoping.ts(9,21): error TS2304: Cannot find name 'store'. +tests/cases/compiler/es6MemberScoping.ts(7,21): error TS2304: Cannot find name 'store'. ==== tests/cases/compiler/es6MemberScoping.ts (1 errors) ==== - - class Foo { constructor(store: string) { } diff --git a/tests/baselines/reference/es6MemberScoping.js b/tests/baselines/reference/es6MemberScoping.js index d38a64c611a..de442616dc3 100644 --- a/tests/baselines/reference/es6MemberScoping.js +++ b/tests/baselines/reference/es6MemberScoping.js @@ -1,6 +1,4 @@ //// [es6MemberScoping.ts] - - class Foo { constructor(store: string) { } diff --git a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js index 3e4475f2ffa..6c2266f10ff 100644 --- a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js +++ b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js @@ -1,5 +1,4 @@ //// [es6ModuleConstEnumDeclaration2.ts] - export const enum e1 { a, b, diff --git a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols index 2e756cf2875..37130cfd124 100644 --- a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols +++ b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols @@ -1,148 +1,147 @@ === tests/cases/compiler/es6ModuleConstEnumDeclaration2.ts === - export const enum e1 { >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) a, ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) b, ->b : Symbol(e1.b, Decl(es6ModuleConstEnumDeclaration2.ts, 2, 6)) +>b : Symbol(e1.b, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 6)) c ->c : Symbol(e1.c, Decl(es6ModuleConstEnumDeclaration2.ts, 3, 6)) +>c : Symbol(e1.c, Decl(es6ModuleConstEnumDeclaration2.ts, 2, 6)) } const enum e2 { ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) x, ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) y, ->y : Symbol(e2.y, Decl(es6ModuleConstEnumDeclaration2.ts, 7, 6)) +>y : Symbol(e2.y, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 6)) z ->z : Symbol(e2.z, Decl(es6ModuleConstEnumDeclaration2.ts, 8, 6)) +>z : Symbol(e2.z, Decl(es6ModuleConstEnumDeclaration2.ts, 7, 6)) } var x = e1.a; ->x : Symbol(x, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 3)) ->e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>x : Symbol(x, Decl(es6ModuleConstEnumDeclaration2.ts, 10, 3)) +>e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) var y = e2.x; ->y : Symbol(y, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 3)) ->e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>y : Symbol(y, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 3)) +>e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) export module m1 { ->m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 13)) +>m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 13)) export const enum e3 { ->e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) +>e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) a, ->a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) +>a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) b, ->b : Symbol(e3.b, Decl(es6ModuleConstEnumDeclaration2.ts, 15, 10)) +>b : Symbol(e3.b, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 10)) c ->c : Symbol(e3.c, Decl(es6ModuleConstEnumDeclaration2.ts, 16, 10)) +>c : Symbol(e3.c, Decl(es6ModuleConstEnumDeclaration2.ts, 15, 10)) } const enum e4 { ->e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 5)) +>e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 17, 5)) x, ->x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 19)) +>x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 19)) y, ->y : Symbol(e4.y, Decl(es6ModuleConstEnumDeclaration2.ts, 20, 10)) +>y : Symbol(e4.y, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 10)) z ->z : Symbol(e4.z, Decl(es6ModuleConstEnumDeclaration2.ts, 21, 10)) +>z : Symbol(e4.z, Decl(es6ModuleConstEnumDeclaration2.ts, 20, 10)) } var x1 = e1.a; ->x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 24, 7)) ->e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 23, 7)) +>e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) var y1 = e2.x; ->y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 25, 7)) ->e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 24, 7)) +>e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) var x2 = e3.a; ->x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 26, 7)) ->e3.a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) ->e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) ->a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) +>x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 25, 7)) +>e3.a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) +>e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) +>a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) var y2 = e4.x; ->y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 27, 7)) ->e4.x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 19)) ->e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 5)) ->x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 19)) +>y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 26, 7)) +>e4.x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 19)) +>e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 17, 5)) +>x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 19)) } module m2 { ->m2 : Symbol(m2, Decl(es6ModuleConstEnumDeclaration2.ts, 28, 1)) +>m2 : Symbol(m2, Decl(es6ModuleConstEnumDeclaration2.ts, 27, 1)) export const enum e5 { ->e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 11)) +>e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 28, 11)) a, ->a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 26)) +>a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 26)) b, ->b : Symbol(e5.b, Decl(es6ModuleConstEnumDeclaration2.ts, 31, 10)) +>b : Symbol(e5.b, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 10)) c ->c : Symbol(e5.c, Decl(es6ModuleConstEnumDeclaration2.ts, 32, 10)) +>c : Symbol(e5.c, Decl(es6ModuleConstEnumDeclaration2.ts, 31, 10)) } const enum e6 { ->e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 5)) +>e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 33, 5)) x, ->x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 19)) +>x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 19)) y, ->y : Symbol(e6.y, Decl(es6ModuleConstEnumDeclaration2.ts, 36, 10)) +>y : Symbol(e6.y, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 10)) z ->z : Symbol(e6.z, Decl(es6ModuleConstEnumDeclaration2.ts, 37, 10)) +>z : Symbol(e6.z, Decl(es6ModuleConstEnumDeclaration2.ts, 36, 10)) } var x1 = e1.a; ->x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 40, 7)) ->e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 39, 7)) +>e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) var y1 = e2.x; ->y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 41, 7)) ->e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 40, 7)) +>e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) var x2 = e5.a; ->x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 42, 7)) ->e5.a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 26)) ->e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 11)) ->a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 26)) +>x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 41, 7)) +>e5.a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 26)) +>e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 28, 11)) +>a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 26)) var y2 = e6.x; ->y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 43, 7)) ->e6.x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 19)) ->e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 5)) ->x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 19)) +>y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 42, 7)) +>e6.x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 19)) +>e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 33, 5)) +>x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 19)) var x3 = m1.e3.a; ->x3 : Symbol(x3, Decl(es6ModuleConstEnumDeclaration2.ts, 44, 7)) ->m1.e3.a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) ->m1.e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) ->m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 13)) ->e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) ->a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) +>x3 : Symbol(x3, Decl(es6ModuleConstEnumDeclaration2.ts, 43, 7)) +>m1.e3.a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) +>m1.e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) +>m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 13)) +>e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) +>a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) } diff --git a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types index ee0cb195a1a..b31fdc63305 100644 --- a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types +++ b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ModuleConstEnumDeclaration2.ts === - export const enum e1 { >e1 : e1 diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt b/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt index fb49f08e2e0..054c431c65d 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt +++ b/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/es6ModuleInternalNamedImports.ts(22,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(23,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(24,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(25,5): error TS1194: Export declarations are not permitted in a namespace. @@ -5,11 +6,9 @@ tests/cases/compiler/es6ModuleInternalNamedImports.ts(26,5): error TS1194: Expor tests/cases/compiler/es6ModuleInternalNamedImports.ts(27,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(28,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(29,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es6ModuleInternalNamedImports.ts(30,5): error TS1194: Export declarations are not permitted in a namespace. ==== tests/cases/compiler/es6ModuleInternalNamedImports.ts (8 errors) ==== - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports.js b/tests/baselines/reference/es6ModuleInternalNamedImports.js index fe2e0217795..b9fa0de2a32 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports.js +++ b/tests/baselines/reference/es6ModuleInternalNamedImports.js @@ -1,5 +1,4 @@ //// [es6ModuleInternalNamedImports.ts] - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt b/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt index af8de2d7fe2..65c326ddb27 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt +++ b/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/es6ModuleInternalNamedImports2.ts(24,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(25,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(26,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(27,5): error TS1194: Export declarations are not permitted in a namespace. @@ -5,11 +6,9 @@ tests/cases/compiler/es6ModuleInternalNamedImports2.ts(28,5): error TS1194: Expo tests/cases/compiler/es6ModuleInternalNamedImports2.ts(29,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(30,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(31,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es6ModuleInternalNamedImports2.ts(32,5): error TS1194: Export declarations are not permitted in a namespace. ==== tests/cases/compiler/es6ModuleInternalNamedImports2.ts (8 errors) ==== - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports2.js b/tests/baselines/reference/es6ModuleInternalNamedImports2.js index 93d8f40c1d2..f5546d47d34 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports2.js +++ b/tests/baselines/reference/es6ModuleInternalNamedImports2.js @@ -1,5 +1,4 @@ //// [es6ModuleInternalNamedImports2.ts] - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6UseOfTopLevelRequire.js b/tests/baselines/reference/es6UseOfTopLevelRequire.js index fa7295df989..ee65d1b7e70 100644 --- a/tests/baselines/reference/es6UseOfTopLevelRequire.js +++ b/tests/baselines/reference/es6UseOfTopLevelRequire.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6UseOfTopLevelRequire.ts] //// //// [b.ts] - export default function require(s: string): void { } diff --git a/tests/baselines/reference/es6UseOfTopLevelRequire.symbols b/tests/baselines/reference/es6UseOfTopLevelRequire.symbols index 710bd675210..de8cdbed9c3 100644 --- a/tests/baselines/reference/es6UseOfTopLevelRequire.symbols +++ b/tests/baselines/reference/es6UseOfTopLevelRequire.symbols @@ -13,10 +13,9 @@ var x = exports + 2; >exports : Symbol(exports, Decl(a.ts, 3, 6)) === tests/cases/compiler/b.ts === - export default function require(s: string): void { >require : Symbol(require, Decl(b.ts, 0, 0)) ->s : Symbol(s, Decl(b.ts, 1, 32)) +>s : Symbol(s, Decl(b.ts, 0, 32)) } === tests/cases/compiler/c.ts === diff --git a/tests/baselines/reference/es6UseOfTopLevelRequire.types b/tests/baselines/reference/es6UseOfTopLevelRequire.types index 06acc9c2b42..11462c850b2 100644 --- a/tests/baselines/reference/es6UseOfTopLevelRequire.types +++ b/tests/baselines/reference/es6UseOfTopLevelRequire.types @@ -17,7 +17,6 @@ var x = exports + 2; >2 : 2 === tests/cases/compiler/b.ts === - export default function require(s: string): void { >require : (s: string) => void >s : string diff --git a/tests/baselines/reference/es6modulekind.js b/tests/baselines/reference/es6modulekind.js index 96b315389d1..06872fe7d9f 100644 --- a/tests/baselines/reference/es6modulekind.js +++ b/tests/baselines/reference/es6modulekind.js @@ -1,5 +1,4 @@ //// [es6modulekind.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es6modulekind.symbols b/tests/baselines/reference/es6modulekind.symbols index 877199729e6..cc563db6826 100644 --- a/tests/baselines/reference/es6modulekind.symbols +++ b/tests/baselines/reference/es6modulekind.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekind.ts === - export default class A >A : Symbol(A, Decl(es6modulekind.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es6modulekind.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6modulekind.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6modulekind.types b/tests/baselines/reference/es6modulekind.types index 8994eb6657a..a8b6fa077f0 100644 --- a/tests/baselines/reference/es6modulekind.types +++ b/tests/baselines/reference/es6modulekind.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekind.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.js b/tests/baselines/reference/es6modulekindWithES2015Target.js index 98808fd1c65..c0762b88eff 100644 --- a/tests/baselines/reference/es6modulekindWithES2015Target.js +++ b/tests/baselines/reference/es6modulekindWithES2015Target.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES2015Target.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.symbols b/tests/baselines/reference/es6modulekindWithES2015Target.symbols index 2b6f8a03aa7..b7cf2e19c74 100644 --- a/tests/baselines/reference/es6modulekindWithES2015Target.symbols +++ b/tests/baselines/reference/es6modulekindWithES2015Target.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES2015Target.ts === - export default class A >A : Symbol(A, Decl(es6modulekindWithES2015Target.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es6modulekindWithES2015Target.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6modulekindWithES2015Target.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.types b/tests/baselines/reference/es6modulekindWithES2015Target.types index 313fb612d8e..018d06e0745 100644 --- a/tests/baselines/reference/es6modulekindWithES2015Target.types +++ b/tests/baselines/reference/es6modulekindWithES2015Target.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES2015Target.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es6modulekindWithES5Target.js b/tests/baselines/reference/es6modulekindWithES5Target.js index 66967cbc89f..8778d178786 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target.js +++ b/tests/baselines/reference/es6modulekindWithES5Target.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target.ts] - export class C { static s = 0; p = 1; diff --git a/tests/baselines/reference/es6modulekindWithES5Target.symbols b/tests/baselines/reference/es6modulekindWithES5Target.symbols index 2d2a3f6732c..edba44a2223 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target.symbols @@ -1,47 +1,46 @@ === tests/cases/compiler/es6modulekindWithES5Target.ts === - export class C { >C : Symbol(C, Decl(es6modulekindWithES5Target.ts, 0, 0)) static s = 0; ->s : Symbol(C.s, Decl(es6modulekindWithES5Target.ts, 1, 16)) +>s : Symbol(C.s, Decl(es6modulekindWithES5Target.ts, 0, 16)) p = 1; ->p : Symbol(C.p, Decl(es6modulekindWithES5Target.ts, 2, 17)) +>p : Symbol(C.p, Decl(es6modulekindWithES5Target.ts, 1, 17)) method() { } ->method : Symbol(C.method, Decl(es6modulekindWithES5Target.ts, 3, 10)) +>method : Symbol(C.method, Decl(es6modulekindWithES5Target.ts, 2, 10)) } export { C as C2 }; ->C : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 6, 8)) ->C2 : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 6, 8)) +>C : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 5, 8)) +>C2 : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 5, 8)) declare function foo(...args: any[]): any; ->foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 6, 19)) ->args : Symbol(args, Decl(es6modulekindWithES5Target.ts, 8, 21)) +>foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 5, 19)) +>args : Symbol(args, Decl(es6modulekindWithES5Target.ts, 7, 21)) @foo ->foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 6, 19)) +>foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 5, 19)) export class D { ->D : Symbol(D, Decl(es6modulekindWithES5Target.ts, 8, 42)) +>D : Symbol(D, Decl(es6modulekindWithES5Target.ts, 7, 42)) static s = 0; ->s : Symbol(D.s, Decl(es6modulekindWithES5Target.ts, 10, 16)) +>s : Symbol(D.s, Decl(es6modulekindWithES5Target.ts, 9, 16)) p = 1; ->p : Symbol(D.p, Decl(es6modulekindWithES5Target.ts, 11, 17)) +>p : Symbol(D.p, Decl(es6modulekindWithES5Target.ts, 10, 17)) method() { } ->method : Symbol(D.method, Decl(es6modulekindWithES5Target.ts, 12, 10)) +>method : Symbol(D.method, Decl(es6modulekindWithES5Target.ts, 11, 10)) } export { D as D2 }; ->D : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 15, 8)) ->D2 : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 15, 8)) +>D : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 14, 8)) +>D2 : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 14, 8)) class E { } ->E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 15, 19)) +>E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 14, 19)) export {E}; ->E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 18, 8)) +>E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 17, 8)) diff --git a/tests/baselines/reference/es6modulekindWithES5Target.types b/tests/baselines/reference/es6modulekindWithES5Target.types index 4b620fb9e17..018114be43d 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target.types +++ b/tests/baselines/reference/es6modulekindWithES5Target.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target.ts === - export class C { >C : C diff --git a/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt b/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt index fd01dafc11f..16dfab25794 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt +++ b/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/es6modulekindWithES5Target10.ts(2,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. -tests/cases/compiler/es6modulekindWithES5Target10.ts(2,20): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target10.ts(7,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/es6modulekindWithES5Target10.ts(1,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. +tests/cases/compiler/es6modulekindWithES5Target10.ts(1,20): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target10.ts(6,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/es6modulekindWithES5Target10.ts (3 errors) ==== - import i = require("mod"); // Error; ~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. diff --git a/tests/baselines/reference/es6modulekindWithES5Target10.js b/tests/baselines/reference/es6modulekindWithES5Target10.js index b8a66241780..037ff12a0b0 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target10.js +++ b/tests/baselines/reference/es6modulekindWithES5Target10.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target10.ts] - import i = require("mod"); // Error; diff --git a/tests/baselines/reference/es6modulekindWithES5Target11.js b/tests/baselines/reference/es6modulekindWithES5Target11.js index 4ec0802a5f5..ed3d44cb538 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target11.js +++ b/tests/baselines/reference/es6modulekindWithES5Target11.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target11.ts] - declare function foo(...args: any[]): any; @foo export default class C { diff --git a/tests/baselines/reference/es6modulekindWithES5Target11.symbols b/tests/baselines/reference/es6modulekindWithES5Target11.symbols index 144d306c5fb..39c351a0e5e 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target11.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target11.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/es6modulekindWithES5Target11.ts === - declare function foo(...args: any[]): any; >foo : Symbol(foo, Decl(es6modulekindWithES5Target11.ts, 0, 0)) ->args : Symbol(args, Decl(es6modulekindWithES5Target11.ts, 1, 21)) +>args : Symbol(args, Decl(es6modulekindWithES5Target11.ts, 0, 21)) @foo >foo : Symbol(foo, Decl(es6modulekindWithES5Target11.ts, 0, 0)) export default class C { ->C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 1, 42)) +>C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 0, 42)) static x() { return C.y; } ->x : Symbol(C.x, Decl(es6modulekindWithES5Target11.ts, 3, 24)) ->C.y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 4, 30)) ->C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 1, 42)) ->y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 4, 30)) +>x : Symbol(C.x, Decl(es6modulekindWithES5Target11.ts, 2, 24)) +>C.y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 3, 30)) +>C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 0, 42)) +>y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 3, 30)) static y = 1 ->y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 4, 30)) +>y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 3, 30)) p = 1; ->p : Symbol(C.p, Decl(es6modulekindWithES5Target11.ts, 5, 16)) +>p : Symbol(C.p, Decl(es6modulekindWithES5Target11.ts, 4, 16)) method() { } ->method : Symbol(C.method, Decl(es6modulekindWithES5Target11.ts, 6, 10)) +>method : Symbol(C.method, Decl(es6modulekindWithES5Target11.ts, 5, 10)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target11.types b/tests/baselines/reference/es6modulekindWithES5Target11.types index e3d922c0443..497d8e0af78 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target11.types +++ b/tests/baselines/reference/es6modulekindWithES5Target11.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target11.ts === - declare function foo(...args: any[]): any; >foo : (...args: any[]) => any >args : any[] diff --git a/tests/baselines/reference/es6modulekindWithES5Target12.js b/tests/baselines/reference/es6modulekindWithES5Target12.js index 74646f73e55..f0ccbf0701e 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target12.js +++ b/tests/baselines/reference/es6modulekindWithES5Target12.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target12.ts] - export class C { } diff --git a/tests/baselines/reference/es6modulekindWithES5Target12.symbols b/tests/baselines/reference/es6modulekindWithES5Target12.symbols index e6469a6300a..a16baab08ce 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target12.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target12.symbols @@ -1,62 +1,61 @@ === tests/cases/compiler/es6modulekindWithES5Target12.ts === - export class C { ->C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 2, 1)) +>C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 1, 1)) } export namespace C { ->C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 2, 1)) +>C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 1, 1)) export const x = 1; ->x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 5, 16)) +>x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 4, 16)) } export enum E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) w = 1 ->w : Symbol(E.w, Decl(es6modulekindWithES5Target12.ts, 8, 15)) +>w : Symbol(E.w, Decl(es6modulekindWithES5Target12.ts, 7, 15)) } export enum E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) x = 2 ->x : Symbol(E.x, Decl(es6modulekindWithES5Target12.ts, 12, 15)) +>x : Symbol(E.x, Decl(es6modulekindWithES5Target12.ts, 11, 15)) } export namespace E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) export const y = 1; ->y : Symbol(y, Decl(es6modulekindWithES5Target12.ts, 17, 16)) +>y : Symbol(y, Decl(es6modulekindWithES5Target12.ts, 16, 16)) } export namespace E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) export const z = 1; ->z : Symbol(z, Decl(es6modulekindWithES5Target12.ts, 21, 16)) +>z : Symbol(z, Decl(es6modulekindWithES5Target12.ts, 20, 16)) } export namespace N { ->N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 22, 1), Decl(es6modulekindWithES5Target12.ts, 25, 1)) +>N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 21, 1), Decl(es6modulekindWithES5Target12.ts, 24, 1)) } export namespace N { ->N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 22, 1), Decl(es6modulekindWithES5Target12.ts, 25, 1)) +>N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 21, 1), Decl(es6modulekindWithES5Target12.ts, 24, 1)) export const x = 1; ->x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 28, 16)) +>x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 27, 16)) } export function F() { ->F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 29, 1), Decl(es6modulekindWithES5Target12.ts, 32, 1)) +>F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 28, 1), Decl(es6modulekindWithES5Target12.ts, 31, 1)) } export namespace F { ->F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 29, 1), Decl(es6modulekindWithES5Target12.ts, 32, 1)) +>F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 28, 1), Decl(es6modulekindWithES5Target12.ts, 31, 1)) export const x = 1; ->x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 35, 16)) +>x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 34, 16)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target12.types b/tests/baselines/reference/es6modulekindWithES5Target12.types index 5bc42cae68a..7d38adb3f46 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target12.types +++ b/tests/baselines/reference/es6modulekindWithES5Target12.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target12.ts === - export class C { >C : C } diff --git a/tests/baselines/reference/es6modulekindWithES5Target2.js b/tests/baselines/reference/es6modulekindWithES5Target2.js index 101ead5cb56..8b2f6dd3c53 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target2.js +++ b/tests/baselines/reference/es6modulekindWithES5Target2.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target2.ts] - export default class C { static s = 0; p = 1; diff --git a/tests/baselines/reference/es6modulekindWithES5Target2.symbols b/tests/baselines/reference/es6modulekindWithES5Target2.symbols index 762121612eb..66f1375e6e5 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target2.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target2.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es6modulekindWithES5Target2.ts === - export default class C { >C : Symbol(C, Decl(es6modulekindWithES5Target2.ts, 0, 0)) static s = 0; ->s : Symbol(C.s, Decl(es6modulekindWithES5Target2.ts, 1, 24)) +>s : Symbol(C.s, Decl(es6modulekindWithES5Target2.ts, 0, 24)) p = 1; ->p : Symbol(C.p, Decl(es6modulekindWithES5Target2.ts, 2, 17)) +>p : Symbol(C.p, Decl(es6modulekindWithES5Target2.ts, 1, 17)) method() { } ->method : Symbol(C.method, Decl(es6modulekindWithES5Target2.ts, 3, 10)) +>method : Symbol(C.method, Decl(es6modulekindWithES5Target2.ts, 2, 10)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target2.types b/tests/baselines/reference/es6modulekindWithES5Target2.types index 6ad697e0c25..6540471c890 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target2.types +++ b/tests/baselines/reference/es6modulekindWithES5Target2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target2.ts === - export default class C { >C : C diff --git a/tests/baselines/reference/es6modulekindWithES5Target3.js b/tests/baselines/reference/es6modulekindWithES5Target3.js index 72e6f97a900..87dd0409097 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target3.js +++ b/tests/baselines/reference/es6modulekindWithES5Target3.js @@ -1,6 +1,4 @@ //// [es6modulekindWithES5Target3.ts] - - declare function foo(...args: any[]): any; @foo export default class D { diff --git a/tests/baselines/reference/es6modulekindWithES5Target3.symbols b/tests/baselines/reference/es6modulekindWithES5Target3.symbols index 3fd26b9033f..cc0b1ecc89d 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target3.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target3.symbols @@ -1,22 +1,20 @@ === tests/cases/compiler/es6modulekindWithES5Target3.ts === - - declare function foo(...args: any[]): any; >foo : Symbol(foo, Decl(es6modulekindWithES5Target3.ts, 0, 0)) ->args : Symbol(args, Decl(es6modulekindWithES5Target3.ts, 2, 21)) +>args : Symbol(args, Decl(es6modulekindWithES5Target3.ts, 0, 21)) @foo >foo : Symbol(foo, Decl(es6modulekindWithES5Target3.ts, 0, 0)) export default class D { ->D : Symbol(D, Decl(es6modulekindWithES5Target3.ts, 2, 42)) +>D : Symbol(D, Decl(es6modulekindWithES5Target3.ts, 0, 42)) static s = 0; ->s : Symbol(D.s, Decl(es6modulekindWithES5Target3.ts, 4, 24)) +>s : Symbol(D.s, Decl(es6modulekindWithES5Target3.ts, 2, 24)) p = 1; ->p : Symbol(D.p, Decl(es6modulekindWithES5Target3.ts, 5, 17)) +>p : Symbol(D.p, Decl(es6modulekindWithES5Target3.ts, 3, 17)) method() { } ->method : Symbol(D.method, Decl(es6modulekindWithES5Target3.ts, 6, 10)) +>method : Symbol(D.method, Decl(es6modulekindWithES5Target3.ts, 4, 10)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target3.types b/tests/baselines/reference/es6modulekindWithES5Target3.types index 78928f56ddd..d2cc641b732 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target3.types +++ b/tests/baselines/reference/es6modulekindWithES5Target3.types @@ -1,6 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target3.ts === - - declare function foo(...args: any[]): any; >foo : (...args: any[]) => any >args : any[] diff --git a/tests/baselines/reference/es6modulekindWithES5Target4.js b/tests/baselines/reference/es6modulekindWithES5Target4.js index b34e68b8111..15b534fe108 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target4.js +++ b/tests/baselines/reference/es6modulekindWithES5Target4.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target4.ts] - class E { } export default E; diff --git a/tests/baselines/reference/es6modulekindWithES5Target4.symbols b/tests/baselines/reference/es6modulekindWithES5Target4.symbols index fdf5bdc6197..f7ff2d07016 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target4.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target4.ts === - class E { } >E : Symbol(E, Decl(es6modulekindWithES5Target4.ts, 0, 0)) diff --git a/tests/baselines/reference/es6modulekindWithES5Target4.types b/tests/baselines/reference/es6modulekindWithES5Target4.types index cd0852cab1a..20bea4e397b 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target4.types +++ b/tests/baselines/reference/es6modulekindWithES5Target4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target4.ts === - class E { } >E : E diff --git a/tests/baselines/reference/es6modulekindWithES5Target5.js b/tests/baselines/reference/es6modulekindWithES5Target5.js index 73560486183..14cacaffe40 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target5.js +++ b/tests/baselines/reference/es6modulekindWithES5Target5.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target5.ts] - export enum E1 { value1 } diff --git a/tests/baselines/reference/es6modulekindWithES5Target5.symbols b/tests/baselines/reference/es6modulekindWithES5Target5.symbols index 5a305ad0f7f..d4401b86d6b 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target5.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target5.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es6modulekindWithES5Target5.ts === - export enum E1 { >E1 : Symbol(E1, Decl(es6modulekindWithES5Target5.ts, 0, 0)) value1 ->value1 : Symbol(E1.value1, Decl(es6modulekindWithES5Target5.ts, 1, 16)) +>value1 : Symbol(E1.value1, Decl(es6modulekindWithES5Target5.ts, 0, 16)) } export const enum E2 { ->E2 : Symbol(E2, Decl(es6modulekindWithES5Target5.ts, 3, 1)) +>E2 : Symbol(E2, Decl(es6modulekindWithES5Target5.ts, 2, 1)) value1 ->value1 : Symbol(E2.value1, Decl(es6modulekindWithES5Target5.ts, 5, 22)) +>value1 : Symbol(E2.value1, Decl(es6modulekindWithES5Target5.ts, 4, 22)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target5.types b/tests/baselines/reference/es6modulekindWithES5Target5.types index 284c72cc0ea..5abe6f5b165 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target5.types +++ b/tests/baselines/reference/es6modulekindWithES5Target5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target5.ts === - export enum E1 { >E1 : E1 diff --git a/tests/baselines/reference/es6modulekindWithES5Target6.js b/tests/baselines/reference/es6modulekindWithES5Target6.js index cff2327dacb..b57b38d17ed 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target6.js +++ b/tests/baselines/reference/es6modulekindWithES5Target6.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target6.ts] - export function f1(d = 0) { } diff --git a/tests/baselines/reference/es6modulekindWithES5Target6.symbols b/tests/baselines/reference/es6modulekindWithES5Target6.symbols index 6e779355f3d..b07af7462ba 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target6.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target6.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/es6modulekindWithES5Target6.ts === - export function f1(d = 0) { >f1 : Symbol(f1, Decl(es6modulekindWithES5Target6.ts, 0, 0)) ->d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 1, 19)) +>d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 0, 19)) } export function f2(...arg) { ->f2 : Symbol(f2, Decl(es6modulekindWithES5Target6.ts, 2, 1)) ->arg : Symbol(arg, Decl(es6modulekindWithES5Target6.ts, 4, 19)) +>f2 : Symbol(f2, Decl(es6modulekindWithES5Target6.ts, 1, 1)) +>arg : Symbol(arg, Decl(es6modulekindWithES5Target6.ts, 3, 19)) } export default function f3(d = 0) { ->f3 : Symbol(f3, Decl(es6modulekindWithES5Target6.ts, 5, 1)) ->d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 7, 27)) +>f3 : Symbol(f3, Decl(es6modulekindWithES5Target6.ts, 4, 1)) +>d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 6, 27)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target6.types b/tests/baselines/reference/es6modulekindWithES5Target6.types index de43a987d4d..5296f4730b3 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target6.types +++ b/tests/baselines/reference/es6modulekindWithES5Target6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target6.ts === - export function f1(d = 0) { >f1 : (d?: number) => void >d : number diff --git a/tests/baselines/reference/es6modulekindWithES5Target7.js b/tests/baselines/reference/es6modulekindWithES5Target7.js index e3e0b4f4549..5d85c9263d4 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target7.js +++ b/tests/baselines/reference/es6modulekindWithES5Target7.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target7.ts] - export namespace N { var x = 0; } diff --git a/tests/baselines/reference/es6modulekindWithES5Target7.symbols b/tests/baselines/reference/es6modulekindWithES5Target7.symbols index 4bf587dd5d3..bcc89efaeab 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target7.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target7.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/es6modulekindWithES5Target7.ts === - export namespace N { >N : Symbol(N, Decl(es6modulekindWithES5Target7.ts, 0, 0)) var x = 0; ->x : Symbol(x, Decl(es6modulekindWithES5Target7.ts, 2, 7)) +>x : Symbol(x, Decl(es6modulekindWithES5Target7.ts, 1, 7)) } export namespace N2 { ->N2 : Symbol(N2, Decl(es6modulekindWithES5Target7.ts, 3, 1)) +>N2 : Symbol(N2, Decl(es6modulekindWithES5Target7.ts, 2, 1)) export interface I { } ->I : Symbol(I, Decl(es6modulekindWithES5Target7.ts, 5, 21)) +>I : Symbol(I, Decl(es6modulekindWithES5Target7.ts, 4, 21)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target7.types b/tests/baselines/reference/es6modulekindWithES5Target7.types index 1c3add3b031..0e534b85c54 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target7.types +++ b/tests/baselines/reference/es6modulekindWithES5Target7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target7.ts === - export namespace N { >N : typeof N diff --git a/tests/baselines/reference/es6modulekindWithES5Target8.js b/tests/baselines/reference/es6modulekindWithES5Target8.js index baab6fdab37..d9a767ec53d 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target8.js +++ b/tests/baselines/reference/es6modulekindWithES5Target8.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target8.ts] - export const c = 0; export let l = 1; diff --git a/tests/baselines/reference/es6modulekindWithES5Target8.symbols b/tests/baselines/reference/es6modulekindWithES5Target8.symbols index e85c76a16fe..1a5e54ce96d 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target8.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target8.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/es6modulekindWithES5Target8.ts === - export const c = 0; ->c : Symbol(c, Decl(es6modulekindWithES5Target8.ts, 1, 12)) +>c : Symbol(c, Decl(es6modulekindWithES5Target8.ts, 0, 12)) export let l = 1; ->l : Symbol(l, Decl(es6modulekindWithES5Target8.ts, 2, 10)) +>l : Symbol(l, Decl(es6modulekindWithES5Target8.ts, 1, 10)) diff --git a/tests/baselines/reference/es6modulekindWithES5Target8.types b/tests/baselines/reference/es6modulekindWithES5Target8.types index 754decea312..4bfea977016 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target8.types +++ b/tests/baselines/reference/es6modulekindWithES5Target8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target8.ts === - export const c = 0; >c : 0 >0 : 0 diff --git a/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt b/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt index 2e9a35a8783..af941e65bbe 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt +++ b/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/es6modulekindWithES5Target9.ts(2,15): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(4,17): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(6,20): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(14,15): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(16,17): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(1,15): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(3,17): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(5,20): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(13,15): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(15,17): error TS2307: Cannot find module 'mod'. ==== tests/cases/compiler/es6modulekindWithES5Target9.ts (5 errors) ==== - import d from "mod"; ~~~~~ !!! error TS2307: Cannot find module 'mod'. diff --git a/tests/baselines/reference/es6modulekindWithES5Target9.js b/tests/baselines/reference/es6modulekindWithES5Target9.js index 97991b40b0c..8b4886664ed 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target9.js +++ b/tests/baselines/reference/es6modulekindWithES5Target9.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target9.ts] - import d from "mod"; import {a} from "mod"; diff --git a/tests/baselines/reference/escapedIdentifiers.js b/tests/baselines/reference/escapedIdentifiers.js index b326dbf1ecc..37dcb2f7798 100644 --- a/tests/baselines/reference/escapedIdentifiers.js +++ b/tests/baselines/reference/escapedIdentifiers.js @@ -1,5 +1,4 @@ //// [escapedIdentifiers.ts] - /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols index 735dede00e2..e414f9cf0f7 100644 --- a/tests/baselines/reference/escapedIdentifiers.symbols +++ b/tests/baselines/reference/escapedIdentifiers.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/escapedIdentifiers.ts === - /* 0 .. \u0030 9 .. \u0039 @@ -13,222 +12,222 @@ // var decl var \u0061 = 1; ->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) +>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) a ++; ->a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) +>a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) \u0061 ++; ->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) +>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) var b = 1; ->b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) +>b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) b ++; ->b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) +>b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) \u0062 ++; ->\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) +>\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) // modules module moduleType1 { ->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) +>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) export var baz1: number; ->baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 22, 14)) } module moduleType\u0032 { ->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) +>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) export var baz2: number; ->baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 25, 14)) } moduleType1.baz1 = 3; ->moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) ->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) ->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) +>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) moduleType\u0031.baz1 = 3; ->moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) ->moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) ->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) +>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) moduleType2.baz2 = 3; ->moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) ->moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) ->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) +>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) moduleType\u0032.baz2 = 3; ->moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) ->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) ->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) +>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) // classes class classType1 { ->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) +>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) public foo1: number; ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) } class classType\u0032 { ->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) +>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) public foo2: number; ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) } var classType1Object1 = new classType1(); ->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3)) ->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) +>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3)) +>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) classType1Object1.foo1 = 2; ->classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) ->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3)) ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) var classType1Object2 = new classType\u0031(); ->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3)) ->classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) +>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3)) +>classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) classType1Object2.foo1 = 2; ->classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) ->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3)) ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) var classType2Object1 = new classType2(); ->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3)) ->classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) +>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3)) +>classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) classType2Object1.foo2 = 2; ->classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) ->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3)) ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) var classType2Object2 = new classType\u0032(); ->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3)) ->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) +>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3)) +>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) classType2Object2.foo2 = 2; ->classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) ->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3)) ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) // interfaces interface interfaceType1 { ->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) +>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) bar1: number; ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) } interface interfaceType\u0032 { ->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) +>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) bar2: number; ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) } var interfaceType1Object1 = { bar1: 0 }; ->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3)) ->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 60, 45)) +>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3)) +>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 59, 45)) interfaceType1Object1.bar1 = 2; ->interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) ->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3)) ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) var interfaceType1Object2 = { bar1: 0 }; ->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3)) ->interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 62, 50)) +>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3)) +>interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 61, 50)) interfaceType1Object2.bar1 = 2; ->interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) ->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3)) ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) var interfaceType2Object1 = { bar2: 0 }; ->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3)) ->interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 64, 45)) +>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3)) +>interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 63, 45)) interfaceType2Object1.bar2 = 2; ->interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) ->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3)) ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) var interfaceType2Object2 = { bar2: 0 }; ->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3)) ->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 66, 50)) +>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3)) +>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 65, 50)) interfaceType2Object2.bar2 = 2; ->interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) ->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3)) ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) // arguments class testClass { ->testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 67, 31)) +>testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 66, 31)) public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { ->func : Symbol(testClass.func, Decl(escapedIdentifiers.ts, 71, 17)) ->arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16)) ->arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29)) ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48)) ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68)) +>func : Symbol(testClass.func, Decl(escapedIdentifiers.ts, 70, 17)) +>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16)) +>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68)) arg\u0031 = 1; ->arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16)) +>arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16)) arg2 = 'string'; ->arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29)) +>arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29)) arg\u0033 = true; ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48)) arg4 = 2; ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68)) } } // constructors class constructorTestClass { ->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1)) +>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1)) constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { ->arg1 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) ->arg\u0032 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) ->arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) ->arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) +>arg1 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) +>arg\u0032 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) +>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) +>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) } } var constructorTestObject = new constructorTestClass(1, 'string', true, 2); ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1)) constructorTestObject.arg\u0031 = 1; ->constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) +>constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) constructorTestObject.arg2 = 'string'; ->constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) +>constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) constructorTestObject.arg\u0033 = true; ->constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) +>constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) constructorTestObject.arg4 = 2; ->constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) +>constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) // Lables diff --git a/tests/baselines/reference/escapedIdentifiers.types b/tests/baselines/reference/escapedIdentifiers.types index e7f19d7144c..6d48bb3392f 100644 --- a/tests/baselines/reference/escapedIdentifiers.types +++ b/tests/baselines/reference/escapedIdentifiers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/escapedIdentifiers.ts === - /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/baselines/reference/excessPropertyErrorsSuppressed.js b/tests/baselines/reference/excessPropertyErrorsSuppressed.js index 1673674c5f3..57116704b13 100644 --- a/tests/baselines/reference/excessPropertyErrorsSuppressed.js +++ b/tests/baselines/reference/excessPropertyErrorsSuppressed.js @@ -1,5 +1,4 @@ //// [excessPropertyErrorsSuppressed.ts] - var x: { a: string } = { a: "hello", b: 42 }; // No error diff --git a/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols b/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols index 01c2846d3e1..9768ed19e44 100644 --- a/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols +++ b/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/excessPropertyErrorsSuppressed.ts === - var x: { a: string } = { a: "hello", b: 42 }; // No error ->x : Symbol(x, Decl(excessPropertyErrorsSuppressed.ts, 1, 3)) ->a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 1, 8)) ->a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 1, 24)) ->b : Symbol(b, Decl(excessPropertyErrorsSuppressed.ts, 1, 36)) +>x : Symbol(x, Decl(excessPropertyErrorsSuppressed.ts, 0, 3)) +>a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 0, 8)) +>a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 0, 24)) +>b : Symbol(b, Decl(excessPropertyErrorsSuppressed.ts, 0, 36)) diff --git a/tests/baselines/reference/excessPropertyErrorsSuppressed.types b/tests/baselines/reference/excessPropertyErrorsSuppressed.types index c0b8f66d840..e1288e969c1 100644 --- a/tests/baselines/reference/excessPropertyErrorsSuppressed.types +++ b/tests/baselines/reference/excessPropertyErrorsSuppressed.types @@ -1,5 +1,4 @@ === tests/cases/compiler/excessPropertyErrorsSuppressed.ts === - var x: { a: string } = { a: "hello", b: 42 }; // No error >x : { a: string; } >a : string diff --git a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js index 218d760d6c5..317629c4cb8 100644 --- a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js +++ b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js @@ -1,5 +1,4 @@ //// [exhaustiveSwitchWithWideningLiteralTypes.ts] - // Repro from #12529 class A { diff --git a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols index 929a394dc7b..e54d4bca63b 100644 --- a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols +++ b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/exhaustiveSwitchWithWideningLiteralTypes.ts === - // Repro from #12529 class A { >A : Symbol(A, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 0, 0)) readonly kind = "A"; // (property) A.kind: "A" ->kind : Symbol(A.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 3, 9)) +>kind : Symbol(A.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 2, 9)) } class B { ->B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 5, 1)) +>B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 4, 1)) readonly kind = "B"; // (property) B.kind: "B" ->kind : Symbol(B.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 7, 9)) +>kind : Symbol(B.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 6, 9)) } function f(value: A | B): number { ->f : Symbol(f, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 9, 1)) ->value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 11, 11)) +>f : Symbol(f, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 8, 1)) +>value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 10, 11)) >A : Symbol(A, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 0, 0)) ->B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 5, 1)) +>B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 4, 1)) switch(value.kind) { ->value.kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 3, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 7, 9)) ->value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 11, 11)) ->kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 3, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 7, 9)) +>value.kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 2, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 6, 9)) +>value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 10, 11)) +>kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 2, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 6, 9)) case "A": return 0; case "B": return 1; diff --git a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types index 3955c80ff1e..8bafad04544 100644 --- a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types +++ b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exhaustiveSwitchWithWideningLiteralTypes.ts === - // Repro from #12529 class A { diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt index c20e4b19008..86410b1b491 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt @@ -1,52 +1,51 @@ -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(7,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(7,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(9,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(10,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(13,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(13,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(14,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(14,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(16,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(16,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(21,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(21,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(23,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(23,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts (45 errors) ==== - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js index 8c6d9e011f6..8a793b4e780 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorInTemplateStringWithSyntaxError1.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt index 015d1f6d6f0..7d3651498c5 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt @@ -1,52 +1,51 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(7,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(8,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(9,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(13,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(13,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(14,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(14,27): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,27): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(16,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(16,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,31): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,31): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,31): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,31): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,34): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,34): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,42): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,42): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,34): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,34): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,42): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,42): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(21,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(21,40): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,40): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(23,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(23,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,44): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,44): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,44): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,44): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,47): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,47): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,55): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,55): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,47): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,47): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,55): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,55): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts (45 errors) ==== - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js index 9ae2d727078..cf8bcfd698f 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorInTemplateStringWithSyntaxError2.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt index 320d9a4d309..0c6fab96f90 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt @@ -1,52 +1,51 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(7,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(8,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(9,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(13,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(13,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(14,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(14,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(16,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(16,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(21,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(21,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(23,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(23,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts (45 errors) ==== - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js index c3711ac281c..bb203db9144 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorInTemplateStringWithSyntaxError3.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt index 4b56e4f4258..76d20997f6d 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt @@ -1,38 +1,37 @@ -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(3,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(4,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(2,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(3,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(4,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(5,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,7): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(7,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(7,7): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(8,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(12,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(13,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(14,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(15,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(16,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(17,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(18,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(19,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(11,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(12,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(13,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(14,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(15,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(16,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(17,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(18,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(20,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(21,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(22,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(23,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(24,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(24,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(25,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(26,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(27,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(28,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(28,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(29,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(30,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(31,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(32,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(32,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(33,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(34,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(35,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(36,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts (31 errors) ==== - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () -1 ** 2; ~~ diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError1.js b/tests/baselines/reference/exponentiationOperatorSyntaxError1.js index 05994151610..667abed731c 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError1.js +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError1.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorSyntaxError1.ts] - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () -1 ** 2; +1 ** 2 @@ -41,7 +40,8 @@ var temp = 10; //// [exponentiationOperatorSyntaxError1.js] // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () -Math.pow(-1, 2); +Math.pow(// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () +-1, 2); Math.pow(+1, 2); Math.pow(1, Math.pow(-2, 3)); Math.pow(1, Math.pow(-2, -3)); diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt index 057ceb0c71d..f144879002e 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt @@ -1,3 +1,6 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(4,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(4,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(4,8): error TS2703: The operand of a delete operator must be a property reference. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,8): error TS2703: The operand of a delete operator must be a property reference. @@ -7,9 +10,9 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,8): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,8): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(10,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(10,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(10,13): error TS2703: The operand of a delete operator must be a property reference. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,13): error TS2703: The operand of a delete operator must be a property reference. @@ -19,9 +22,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,13): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,13): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(15,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(15,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(16,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(16,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(17,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -30,8 +32,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(18,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(19,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(20,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(20,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(21,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(21,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(22,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(22,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(23,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -40,8 +42,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(24,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(27,1): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(27,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(29,1): error TS2532: Object is possibly 'undefined'. @@ -50,8 +52,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(30,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(33,6): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(33,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(35,6): error TS2532: Object is possibly 'undefined'. @@ -60,18 +62,18 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(36,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(39,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(40,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(41,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(42,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(43,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(44,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(45,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(46,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(47,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(48,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(49,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(50,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(51,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(51,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(52,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -80,8 +82,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(54,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(55,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(56,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(56,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(57,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(57,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(58,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(58,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(59,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -90,17 +92,14 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(60,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(61,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(61,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(62,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(62,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(63,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(64,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(65,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(66,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(67,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(68,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts (99 errors) ==== - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () var temp: any; diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.js b/tests/baselines/reference/exponentiationOperatorSyntaxError2.js index e443b756575..aad09c8e26d 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError2.js +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorSyntaxError2.ts] - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () var temp: any; diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt index 53379f29933..5c659f24508 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt @@ -1,19 +1,18 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(1,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(2,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(3,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(4,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(5,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(5,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(6,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(9,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(11,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(12,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(15,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts (12 errors) ==== - var a = 1 ** `${ 3 }`; ~~~~~~~~ !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js index 5bd9a9609a0..530a106d09d 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorWithTemplateStringInvalid.ts] - var a = 1 ** `${ 3 }`; var b = 1 ** `2${ 3 }`; var c = 1 ** `${ 3 }4`; diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt index 39ade9df205..ed26fd48c75 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt @@ -1,20 +1,19 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(1,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(2,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(3,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(4,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(5,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(5,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(6,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(9,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(11,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(12,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(15,1): error TS2304: Cannot find name 'kj'. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(15,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,1): error TS2304: Cannot find name 'kj'. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts (13 errors) ==== - var a = 1 ** `${ 3 }`; ~~~~~~~~ !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js index cde5133039f..2f1e7356536 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorWithTemplateStringInvalidES6.ts] - var a = 1 ** `${ 3 }`; var b = 1 ** `2${ 3 }`; var c = 1 ** `${ 3 }4`; diff --git a/tests/baselines/reference/exportAndImport-es3-amd.js b/tests/baselines/reference/exportAndImport-es3-amd.js index d19de0c78b0..ff341f922b5 100644 --- a/tests/baselines/reference/exportAndImport-es3-amd.js +++ b/tests/baselines/reference/exportAndImport-es3-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es3-amd.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es3-amd.symbols b/tests/baselines/reference/exportAndImport-es3-amd.symbols index 66e51659841..b8d336ab3a1 100644 --- a/tests/baselines/reference/exportAndImport-es3-amd.symbols +++ b/tests/baselines/reference/exportAndImport-es3-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es3-amd.types b/tests/baselines/reference/exportAndImport-es3-amd.types index 48136c8779d..b70c5171f00 100644 --- a/tests/baselines/reference/exportAndImport-es3-amd.types +++ b/tests/baselines/reference/exportAndImport-es3-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAndImport-es3.js b/tests/baselines/reference/exportAndImport-es3.js index 13b6f1eaf48..48b3e94a2f2 100644 --- a/tests/baselines/reference/exportAndImport-es3.js +++ b/tests/baselines/reference/exportAndImport-es3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es3.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es3.symbols b/tests/baselines/reference/exportAndImport-es3.symbols index 746f89927b2..7f947a5f4d4 100644 --- a/tests/baselines/reference/exportAndImport-es3.symbols +++ b/tests/baselines/reference/exportAndImport-es3.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es3.types b/tests/baselines/reference/exportAndImport-es3.types index 9bae430e231..8414696adca 100644 --- a/tests/baselines/reference/exportAndImport-es3.types +++ b/tests/baselines/reference/exportAndImport-es3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAndImport-es5-amd.js b/tests/baselines/reference/exportAndImport-es5-amd.js index 60b1246b616..d471d76da51 100644 --- a/tests/baselines/reference/exportAndImport-es5-amd.js +++ b/tests/baselines/reference/exportAndImport-es5-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es5-amd.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es5-amd.symbols b/tests/baselines/reference/exportAndImport-es5-amd.symbols index 66e51659841..b8d336ab3a1 100644 --- a/tests/baselines/reference/exportAndImport-es5-amd.symbols +++ b/tests/baselines/reference/exportAndImport-es5-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es5-amd.types b/tests/baselines/reference/exportAndImport-es5-amd.types index 48136c8779d..b70c5171f00 100644 --- a/tests/baselines/reference/exportAndImport-es5-amd.types +++ b/tests/baselines/reference/exportAndImport-es5-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAndImport-es5.js b/tests/baselines/reference/exportAndImport-es5.js index f4bc496e6b2..c329b650d6e 100644 --- a/tests/baselines/reference/exportAndImport-es5.js +++ b/tests/baselines/reference/exportAndImport-es5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es5.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es5.symbols b/tests/baselines/reference/exportAndImport-es5.symbols index 66e51659841..b8d336ab3a1 100644 --- a/tests/baselines/reference/exportAndImport-es5.symbols +++ b/tests/baselines/reference/exportAndImport-es5.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es5.types b/tests/baselines/reference/exportAndImport-es5.types index 48136c8779d..b70c5171f00 100644 --- a/tests/baselines/reference/exportAndImport-es5.types +++ b/tests/baselines/reference/exportAndImport-es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js index d4b6961cfe9..2d36cffdd17 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportAssignedTypeAsTypeAnnotation.ts] //// //// [exportAssignedTypeAsTypeAnnotation_0.ts] - interface x { (): Date; foo: string; diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols index 79392369c3f..c383b8fd9e0 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols @@ -8,7 +8,6 @@ var t2: test; // should not raise a 'container type' error >test : Symbol(test, Decl(exportAssignedTypeAsTypeAnnotation_1.ts, 0, 0)) === tests/cases/compiler/exportAssignedTypeAsTypeAnnotation_0.ts === - interface x { >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0)) @@ -16,7 +15,7 @@ interface x { >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo: string; ->foo : Symbol(x.foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 2, 13)) +>foo : Symbol(x.foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 1, 13)) } export = x; >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0)) diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types index 553dbe35c4f..2245808b226 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types @@ -8,7 +8,6 @@ var t2: test; // should not raise a 'container type' error >test : test === tests/cases/compiler/exportAssignedTypeAsTypeAnnotation_0.ts === - interface x { >x : x diff --git a/tests/baselines/reference/exportCodeGen.js b/tests/baselines/reference/exportCodeGen.js index d72c633731d..9adde81e0fe 100644 --- a/tests/baselines/reference/exportCodeGen.js +++ b/tests/baselines/reference/exportCodeGen.js @@ -1,5 +1,4 @@ //// [exportCodeGen.ts] - // should replace all refs to 'x' in the body, // with fully qualified module A { diff --git a/tests/baselines/reference/exportCodeGen.symbols b/tests/baselines/reference/exportCodeGen.symbols index b664704d049..bc390bc83e0 100644 --- a/tests/baselines/reference/exportCodeGen.symbols +++ b/tests/baselines/reference/exportCodeGen.symbols @@ -1,42 +1,41 @@ === tests/cases/conformance/internalModules/codeGeneration/exportCodeGen.ts === - // should replace all refs to 'x' in the body, // with fully qualified module A { >A : Symbol(A, Decl(exportCodeGen.ts, 0, 0)) export var x = 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 4, 14)) +>x : Symbol(x, Decl(exportCodeGen.ts, 3, 14)) function lt12() { ->lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 4, 22)) +>lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 3, 22)) return x < 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 4, 14)) +>x : Symbol(x, Decl(exportCodeGen.ts, 3, 14)) } } // should not fully qualify 'x' module B { ->B : Symbol(B, Decl(exportCodeGen.ts, 8, 1)) +>B : Symbol(B, Decl(exportCodeGen.ts, 7, 1)) var x = 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 12, 7)) +>x : Symbol(x, Decl(exportCodeGen.ts, 11, 7)) function lt12() { ->lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 12, 15)) +>lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 11, 15)) return x < 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 12, 7)) +>x : Symbol(x, Decl(exportCodeGen.ts, 11, 7)) } } // not copied, since not exported module C { ->C : Symbol(C, Decl(exportCodeGen.ts, 16, 1)) +>C : Symbol(C, Decl(exportCodeGen.ts, 15, 1)) function no() { ->no : Symbol(no, Decl(exportCodeGen.ts, 19, 10)) +>no : Symbol(no, Decl(exportCodeGen.ts, 18, 10)) return false; } @@ -44,10 +43,10 @@ module C { // copies, since exported module D { ->D : Symbol(D, Decl(exportCodeGen.ts, 23, 1)) +>D : Symbol(D, Decl(exportCodeGen.ts, 22, 1)) export function yes() { ->yes : Symbol(yes, Decl(exportCodeGen.ts, 26, 10)) +>yes : Symbol(yes, Decl(exportCodeGen.ts, 25, 10)) return true; } @@ -55,55 +54,55 @@ module D { // validate all exportable statements module E { ->E : Symbol(E, Decl(exportCodeGen.ts, 30, 1)) +>E : Symbol(E, Decl(exportCodeGen.ts, 29, 1)) export enum Color { Red } ->Color : Symbol(Color, Decl(exportCodeGen.ts, 33, 10)) ->Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 34, 23)) +>Color : Symbol(Color, Decl(exportCodeGen.ts, 32, 10)) +>Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 33, 23)) export function fn() { } ->fn : Symbol(fn, Decl(exportCodeGen.ts, 34, 29)) +>fn : Symbol(fn, Decl(exportCodeGen.ts, 33, 29)) export interface I { id: number } ->I : Symbol(I, Decl(exportCodeGen.ts, 35, 28)) ->id : Symbol(I.id, Decl(exportCodeGen.ts, 36, 24)) +>I : Symbol(I, Decl(exportCodeGen.ts, 34, 28)) +>id : Symbol(I.id, Decl(exportCodeGen.ts, 35, 24)) export class C { name: string } ->C : Symbol(C, Decl(exportCodeGen.ts, 36, 37)) ->name : Symbol(C.name, Decl(exportCodeGen.ts, 37, 20)) +>C : Symbol(C, Decl(exportCodeGen.ts, 35, 37)) +>name : Symbol(C.name, Decl(exportCodeGen.ts, 36, 20)) export module M { ->M : Symbol(M, Decl(exportCodeGen.ts, 37, 35)) +>M : Symbol(M, Decl(exportCodeGen.ts, 36, 35)) export var x = 42; ->x : Symbol(x, Decl(exportCodeGen.ts, 39, 18)) +>x : Symbol(x, Decl(exportCodeGen.ts, 38, 18)) } } // validate all exportable statements, // which are not exported module F { ->F : Symbol(F, Decl(exportCodeGen.ts, 41, 1)) +>F : Symbol(F, Decl(exportCodeGen.ts, 40, 1)) enum Color { Red } ->Color : Symbol(Color, Decl(exportCodeGen.ts, 45, 10)) ->Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 46, 16)) +>Color : Symbol(Color, Decl(exportCodeGen.ts, 44, 10)) +>Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 45, 16)) function fn() { } ->fn : Symbol(fn, Decl(exportCodeGen.ts, 46, 22)) +>fn : Symbol(fn, Decl(exportCodeGen.ts, 45, 22)) interface I { id: number } ->I : Symbol(I, Decl(exportCodeGen.ts, 47, 21)) ->id : Symbol(I.id, Decl(exportCodeGen.ts, 48, 17)) +>I : Symbol(I, Decl(exportCodeGen.ts, 46, 21)) +>id : Symbol(I.id, Decl(exportCodeGen.ts, 47, 17)) class C { name: string } ->C : Symbol(C, Decl(exportCodeGen.ts, 48, 30)) ->name : Symbol(C.name, Decl(exportCodeGen.ts, 49, 13)) +>C : Symbol(C, Decl(exportCodeGen.ts, 47, 30)) +>name : Symbol(C.name, Decl(exportCodeGen.ts, 48, 13)) module M { ->M : Symbol(M, Decl(exportCodeGen.ts, 49, 28)) +>M : Symbol(M, Decl(exportCodeGen.ts, 48, 28)) var x = 42; ->x : Symbol(x, Decl(exportCodeGen.ts, 51, 11)) +>x : Symbol(x, Decl(exportCodeGen.ts, 50, 11)) } } diff --git a/tests/baselines/reference/exportCodeGen.types b/tests/baselines/reference/exportCodeGen.types index 03d4ea0d977..3aa5c9700c6 100644 --- a/tests/baselines/reference/exportCodeGen.types +++ b/tests/baselines/reference/exportCodeGen.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/codeGeneration/exportCodeGen.ts === - // should replace all refs to 'x' in the body, // with fully qualified module A { diff --git a/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt b/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt index 58973f2a096..ab86e0ee65b 100644 --- a/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt +++ b/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/exportDeclarationInInternalModule.ts(14,19): error TS1141: String literal expected. +tests/cases/compiler/exportDeclarationInInternalModule.ts(13,19): error TS1141: String literal expected. ==== tests/cases/compiler/exportDeclarationInInternalModule.ts (1 errors) ==== - class Bbb { } diff --git a/tests/baselines/reference/exportDeclarationInInternalModule.js b/tests/baselines/reference/exportDeclarationInInternalModule.js index dde865bd2c7..7c3345739c3 100644 --- a/tests/baselines/reference/exportDeclarationInInternalModule.js +++ b/tests/baselines/reference/exportDeclarationInInternalModule.js @@ -1,5 +1,4 @@ //// [exportDeclarationInInternalModule.ts] - class Bbb { } diff --git a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js index e0165098b20..c9c681ac40b 100644 --- a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js +++ b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportDeclarationWithModuleSpecifierNameOnNextLine1.ts] //// //// [t1.ts] - export var x = "x"; //// [t2.ts] diff --git a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols index 331766f7712..10644407572 100644 --- a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols +++ b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) === tests/cases/compiler/t2.ts === export { x } from diff --git a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types index ec229047501..510ccc29468 100644 --- a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types +++ b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js index d458433aed4..31191e213ef 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js @@ -1,5 +1,4 @@ //// [exportDeclarationsInAmbientNamespaces.ts] - declare namespace Q { function _try(method: Function, ...args: any[]): any; export { _try as try }; diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols index 99e70fe4595..4cf100c1fa7 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/exportDeclarationsInAmbientNamespaces.ts === - declare namespace Q { >Q : Symbol(Q, Decl(exportDeclarationsInAmbientNamespaces.ts, 0, 0)) function _try(method: Function, ...args: any[]): any; ->_try : Symbol(_try, Decl(exportDeclarationsInAmbientNamespaces.ts, 1, 21)) ->method : Symbol(method, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 18)) +>_try : Symbol(_try, Decl(exportDeclarationsInAmbientNamespaces.ts, 0, 21)) +>method : Symbol(method, Decl(exportDeclarationsInAmbientNamespaces.ts, 1, 18)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->args : Symbol(args, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 35)) +>args : Symbol(args, Decl(exportDeclarationsInAmbientNamespaces.ts, 1, 35)) export { _try as try }; ->_try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) ->try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) +>_try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) +>try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) } Q.try(() => { }); ->Q.try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) +>Q.try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) >Q : Symbol(Q, Decl(exportDeclarationsInAmbientNamespaces.ts, 0, 0)) ->try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) +>try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types index a46d99454f9..9c67482186c 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exportDeclarationsInAmbientNamespaces.ts === - declare namespace Q { >Q : typeof Q diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt index 54c04bd9b1d..8abb7aa38c4 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/exportDeclarationsInAmbientNamespaces2.ts(7,23): error TS1194: Export declarations are not permitted in a namespace. +tests/cases/compiler/exportDeclarationsInAmbientNamespaces2.ts(6,23): error TS1194: Export declarations are not permitted in a namespace. ==== tests/cases/compiler/exportDeclarationsInAmbientNamespaces2.ts (1 errors) ==== - declare module "mod" { export var x: number; } diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js index 6896f13025d..7970ee74fc5 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js @@ -1,5 +1,4 @@ //// [exportDeclarationsInAmbientNamespaces2.ts] - declare module "mod" { export var x: number; } diff --git a/tests/baselines/reference/exportDeclaredModule.js b/tests/baselines/reference/exportDeclaredModule.js index 473ebaa0492..e0d3b252025 100644 --- a/tests/baselines/reference/exportDeclaredModule.js +++ b/tests/baselines/reference/exportDeclaredModule.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/externalModules/exportDeclaredModule.ts] //// //// [foo1.ts] - declare module M1 { export var a: string; export function b(): number; diff --git a/tests/baselines/reference/exportDeclaredModule.symbols b/tests/baselines/reference/exportDeclaredModule.symbols index a5259f795d9..5230f70a71c 100644 --- a/tests/baselines/reference/exportDeclaredModule.symbols +++ b/tests/baselines/reference/exportDeclaredModule.symbols @@ -4,20 +4,19 @@ import foo1 = require('./foo1'); var x: number = foo1.b(); >x : Symbol(x, Decl(foo2.ts, 1, 3)) ->foo1.b : Symbol(foo1.b, Decl(foo1.ts, 2, 22)) +>foo1.b : Symbol(foo1.b, Decl(foo1.ts, 1, 22)) >foo1 : Symbol(foo1, Decl(foo2.ts, 0, 0)) ->b : Symbol(foo1.b, Decl(foo1.ts, 2, 22)) +>b : Symbol(foo1.b, Decl(foo1.ts, 1, 22)) === tests/cases/conformance/externalModules/foo1.ts === - declare module M1 { >M1 : Symbol(M1, Decl(foo1.ts, 0, 0)) export var a: string; ->a : Symbol(a, Decl(foo1.ts, 2, 11)) +>a : Symbol(a, Decl(foo1.ts, 1, 11)) export function b(): number; ->b : Symbol(b, Decl(foo1.ts, 2, 22)) +>b : Symbol(b, Decl(foo1.ts, 1, 22)) } export = M1; >M1 : Symbol(M1, Decl(foo1.ts, 0, 0)) diff --git a/tests/baselines/reference/exportDeclaredModule.types b/tests/baselines/reference/exportDeclaredModule.types index 00bb50ffa09..93e225852ef 100644 --- a/tests/baselines/reference/exportDeclaredModule.types +++ b/tests/baselines/reference/exportDeclaredModule.types @@ -10,7 +10,6 @@ var x: number = foo1.b(); >b : () => number === tests/cases/conformance/externalModules/foo1.ts === - declare module M1 { >M1 : typeof M1 diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.js b/tests/baselines/reference/exportDefaultAsyncFunction2.js index 7b79bed9408..8f889381140 100644 --- a/tests/baselines/reference/exportDefaultAsyncFunction2.js +++ b/tests/baselines/reference/exportDefaultAsyncFunction2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportDefaultAsyncFunction2.ts] //// //// [asyncawait.ts] - export function async(...args: any[]): any { } export function await(...args: any[]): any { } diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols index cffbf284573..02b32f7ee28 100644 --- a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols +++ b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/asyncawait.ts === - export function async(...args: any[]): any { } >async : Symbol(async, Decl(asyncawait.ts, 0, 0)) ->T : Symbol(T, Decl(asyncawait.ts, 1, 22)) ->args : Symbol(args, Decl(asyncawait.ts, 1, 25)) +>T : Symbol(T, Decl(asyncawait.ts, 0, 22)) +>args : Symbol(args, Decl(asyncawait.ts, 0, 25)) export function await(...args: any[]): any { } ->await : Symbol(await, Decl(asyncawait.ts, 1, 49)) ->args : Symbol(args, Decl(asyncawait.ts, 2, 22)) +>await : Symbol(await, Decl(asyncawait.ts, 0, 49)) +>args : Symbol(args, Decl(asyncawait.ts, 1, 22)) === tests/cases/compiler/a.ts === import { async, await } from 'asyncawait'; diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.types b/tests/baselines/reference/exportDefaultAsyncFunction2.types index a9ff903e53a..9aad9fb98ec 100644 --- a/tests/baselines/reference/exportDefaultAsyncFunction2.types +++ b/tests/baselines/reference/exportDefaultAsyncFunction2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncawait.ts === - export function async(...args: any[]): any { } >async : (...args: any[]) => any >T : T diff --git a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js index f2b98e6eb44..c76a7b0806d 100644 --- a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js +++ b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js @@ -1,5 +1,4 @@ //// [exportDefaultForNonInstantiatedModule.ts] - module m { export interface foo { } diff --git a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols index eb0836fd519..a0f061a72d0 100644 --- a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols +++ b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/exportDefaultForNonInstantiatedModule.ts === - module m { >m : Symbol(m, Decl(exportDefaultForNonInstantiatedModule.ts, 0, 0)) export interface foo { ->foo : Symbol(foo, Decl(exportDefaultForNonInstantiatedModule.ts, 1, 10)) +>foo : Symbol(foo, Decl(exportDefaultForNonInstantiatedModule.ts, 0, 10)) } } // Should not be emitted diff --git a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types index 6ec8f9868a3..388854d9d16 100644 --- a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types +++ b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exportDefaultForNonInstantiatedModule.ts === - module m { >m : any diff --git a/tests/baselines/reference/exportDefaultInJsFile01.errors.txt b/tests/baselines/reference/exportDefaultInJsFile01.errors.txt index 78b2ee664b9..a281df59289 100644 --- a/tests/baselines/reference/exportDefaultInJsFile01.errors.txt +++ b/tests/baselines/reference/exportDefaultInJsFile01.errors.txt @@ -5,5 +5,4 @@ error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile01.js' beca !!! error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile01.js' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/conformance/salsa/myFile01.js (0 errors) ==== - export default "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultInJsFile02.errors.txt b/tests/baselines/reference/exportDefaultInJsFile02.errors.txt index f53233a1eff..7155f427b2d 100644 --- a/tests/baselines/reference/exportDefaultInJsFile02.errors.txt +++ b/tests/baselines/reference/exportDefaultInJsFile02.errors.txt @@ -5,5 +5,4 @@ error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile02.js' beca !!! error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile02.js' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/conformance/salsa/myFile02.js (0 errors) ==== - export default "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/exportEqualCallable.js b/tests/baselines/reference/exportEqualCallable.js index 177e3943ac7..830af3a2a36 100644 --- a/tests/baselines/reference/exportEqualCallable.js +++ b/tests/baselines/reference/exportEqualCallable.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportEqualCallable.ts] //// //// [exportEqualCallable_0.ts] - var server: { (): any; }; diff --git a/tests/baselines/reference/exportEqualCallable.symbols b/tests/baselines/reference/exportEqualCallable.symbols index df1c6da8c7b..38c9b8f66e0 100644 --- a/tests/baselines/reference/exportEqualCallable.symbols +++ b/tests/baselines/reference/exportEqualCallable.symbols @@ -7,12 +7,11 @@ connect(); >connect : Symbol(connect, Decl(exportEqualCallable_1.ts, 0, 0)) === tests/cases/compiler/exportEqualCallable_0.ts === - var server: { ->server : Symbol(server, Decl(exportEqualCallable_0.ts, 1, 3)) +>server : Symbol(server, Decl(exportEqualCallable_0.ts, 0, 3)) (): any; }; export = server; ->server : Symbol(server, Decl(exportEqualCallable_0.ts, 1, 3)) +>server : Symbol(server, Decl(exportEqualCallable_0.ts, 0, 3)) diff --git a/tests/baselines/reference/exportEqualCallable.types b/tests/baselines/reference/exportEqualCallable.types index 0a084523137..6ea74aa84bf 100644 --- a/tests/baselines/reference/exportEqualCallable.types +++ b/tests/baselines/reference/exportEqualCallable.types @@ -8,7 +8,6 @@ connect(); >connect : () => any === tests/cases/compiler/exportEqualCallable_0.ts === - var server: { >server : () => any diff --git a/tests/baselines/reference/exportEqualsDefaultProperty.js b/tests/baselines/reference/exportEqualsDefaultProperty.js index 9cf7a7b2ee8..3e7fc4d12af 100644 --- a/tests/baselines/reference/exportEqualsDefaultProperty.js +++ b/tests/baselines/reference/exportEqualsDefaultProperty.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportEqualsDefaultProperty.ts] //// //// [exp.ts] - var x = { "greeting": "hello, world", "default": 42 diff --git a/tests/baselines/reference/exportEqualsDefaultProperty.symbols b/tests/baselines/reference/exportEqualsDefaultProperty.symbols index 54bbbde6956..99f4cb22530 100644 --- a/tests/baselines/reference/exportEqualsDefaultProperty.symbols +++ b/tests/baselines/reference/exportEqualsDefaultProperty.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/exp.ts === - var x = { ->x : Symbol(x, Decl(exp.ts, 1, 3)) +>x : Symbol(x, Decl(exp.ts, 0, 3)) "greeting": "hello, world", "default": 42 }; export = x ->x : Symbol(x, Decl(exp.ts, 1, 3)) +>x : Symbol(x, Decl(exp.ts, 0, 3)) === tests/cases/compiler/imp.ts === import foo from "./exp"; diff --git a/tests/baselines/reference/exportEqualsDefaultProperty.types b/tests/baselines/reference/exportEqualsDefaultProperty.types index b6e3be008a1..57fe40a833a 100644 --- a/tests/baselines/reference/exportEqualsDefaultProperty.types +++ b/tests/baselines/reference/exportEqualsDefaultProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exp.ts === - var x = { >x : { "greeting": string; "default": number; } >{ "greeting": "hello, world", "default": 42} : { "greeting": string; "default": number; } diff --git a/tests/baselines/reference/exportImport.js b/tests/baselines/reference/exportImport.js index 615f3d266ab..031dc8974ed 100644 --- a/tests/baselines/reference/exportImport.js +++ b/tests/baselines/reference/exportImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportImport.ts] //// //// [w1.ts] - export = Widget1 class Widget1 { name = 'one'; } diff --git a/tests/baselines/reference/exportImport.symbols b/tests/baselines/reference/exportImport.symbols index 9f76955b9e6..415776d6c55 100644 --- a/tests/baselines/reference/exportImport.symbols +++ b/tests/baselines/reference/exportImport.symbols @@ -13,13 +13,12 @@ export function w(): e.w { // Should be OK >w : Symbol(e.w, Decl(exporter.ts, 0, 0)) } === tests/cases/compiler/w1.ts === - export = Widget1 ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) class Widget1 { name = 'one'; } ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) ->name : Symbol(Widget1.name, Decl(w1.ts, 2, 15)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) +>name : Symbol(Widget1.name, Decl(w1.ts, 1, 15)) === tests/cases/compiler/exporter.ts === export import w = require('./w1'); diff --git a/tests/baselines/reference/exportImport.types b/tests/baselines/reference/exportImport.types index decfe97a594..f06204bef68 100644 --- a/tests/baselines/reference/exportImport.types +++ b/tests/baselines/reference/exportImport.types @@ -14,7 +14,6 @@ export function w(): e.w { // Should be OK >w : typeof e.w } === tests/cases/compiler/w1.ts === - export = Widget1 >Widget1 : Widget1 diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.js b/tests/baselines/reference/exportImportNonInstantiatedModule2.js index 1394d7492dd..a1217fa485b 100644 --- a/tests/baselines/reference/exportImportNonInstantiatedModule2.js +++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportImportNonInstantiatedModule2.ts] //// //// [w1.ts] - export = Widget1 interface Widget1 { name: string; } diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols index 148fd03b828..67d05bf4cea 100644 --- a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols +++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols @@ -11,13 +11,12 @@ export function w(): e.w { // Should be OK >name : Symbol(name, Decl(consumer.ts, 3, 12)) } === tests/cases/compiler/w1.ts === - export = Widget1 ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) interface Widget1 { name: string; } ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) ->name : Symbol(Widget1.name, Decl(w1.ts, 2, 19)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) +>name : Symbol(Widget1.name, Decl(w1.ts, 1, 19)) === tests/cases/compiler/exporter.ts === export import w = require('./w1'); diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.types b/tests/baselines/reference/exportImportNonInstantiatedModule2.types index 01016fcc4ec..9c01926526f 100644 --- a/tests/baselines/reference/exportImportNonInstantiatedModule2.types +++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.types @@ -13,7 +13,6 @@ export function w(): e.w { // Should be OK >'value' : "value" } === tests/cases/compiler/w1.ts === - export = Widget1 >Widget1 : Widget1 diff --git a/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt index 28d7253a70c..d62adf754d6 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesAMD.js b/tests/baselines/reference/exportNonInitializedVariablesAMD.js index f7ee0b8d4d8..62b0e45e3a9 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesAMD.js +++ b/tests/baselines/reference/exportNonInitializedVariablesAMD.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesAMD.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt index 84d4cab9c83..8dc319b6bab 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js index 7623127aee8..362798c1516 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js +++ b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesCommonJS.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt index 08e1d9588b6..84f9bcb59a4 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesES6.js b/tests/baselines/reference/exportNonInitializedVariablesES6.js index e4f47b2dc68..20093a5edeb 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesES6.js +++ b/tests/baselines/reference/exportNonInitializedVariablesES6.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesES6.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt index 1e461ea7253..cce77c1db43 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesSystem.js b/tests/baselines/reference/exportNonInitializedVariablesSystem.js index 6c44da04802..e54719558cd 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesSystem.js +++ b/tests/baselines/reference/exportNonInitializedVariablesSystem.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesSystem.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt index b180c138501..9e9c493c7d2 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesUMD.js b/tests/baselines/reference/exportNonInitializedVariablesUMD.js index 504c6e70084..cd6ef353fe3 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesUMD.js +++ b/tests/baselines/reference/exportNonInitializedVariablesUMD.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesUMD.ts] - var; let; const; diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt b/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt index 559b9d5fbfe..d2f103a91fa 100644 --- a/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt +++ b/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/b.ts(1,9): error TS2661: Cannot export 'X'. Only local decl ==== tests/cases/compiler/a.d.ts (0 errors) ==== - declare class X { } ==== tests/cases/compiler/b.ts (1 errors) ==== diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.js b/tests/baselines/reference/exportSpecifierForAGlobal.js index fe59f5071f2..6023b7c7f14 100644 --- a/tests/baselines/reference/exportSpecifierForAGlobal.js +++ b/tests/baselines/reference/exportSpecifierForAGlobal.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportSpecifierForAGlobal.ts] //// //// [a.d.ts] - declare class X { } //// [b.ts] diff --git a/tests/baselines/reference/exportStar-amd.errors.txt b/tests/baselines/reference/exportStar-amd.errors.txt index edd5c0d51bd..a667c90224e 100644 --- a/tests/baselines/reference/exportStar-amd.errors.txt +++ b/tests/baselines/reference/exportStar-amd.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/es6/modules/t4.ts(3,1): error TS2308: Module "./t1" has ==== tests/cases/conformance/es6/modules/t1.ts (0 errors) ==== - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStar-amd.js b/tests/baselines/reference/exportStar-amd.js index f25a68a5aa6..7658c470e55 100644 --- a/tests/baselines/reference/exportStar-amd.js +++ b/tests/baselines/reference/exportStar-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportStar-amd.ts] //// //// [t1.ts] - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStar.errors.txt b/tests/baselines/reference/exportStar.errors.txt index edd5c0d51bd..a667c90224e 100644 --- a/tests/baselines/reference/exportStar.errors.txt +++ b/tests/baselines/reference/exportStar.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/es6/modules/t4.ts(3,1): error TS2308: Module "./t1" has ==== tests/cases/conformance/es6/modules/t1.ts (0 errors) ==== - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStar.js b/tests/baselines/reference/exportStar.js index a188cefd8b6..36818f8ae9b 100644 --- a/tests/baselines/reference/exportStar.js +++ b/tests/baselines/reference/exportStar.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportStar.ts] //// //// [t1.ts] - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStarForValues.js b/tests/baselines/reference/exportStarForValues.js index 8376ec1927e..dd8b9c7b4d4 100644 --- a/tests/baselines/reference/exportStarForValues.js +++ b/tests/baselines/reference/exportStarForValues.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues.symbols b/tests/baselines/reference/exportStarForValues.symbols index 343c7b23a14..44db8692ac8 100644 --- a/tests/baselines/reference/exportStarForValues.symbols +++ b/tests/baselines/reference/exportStarForValues.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues.types b/tests/baselines/reference/exportStarForValues.types index b326a7e7ff6..e0285bc614e 100644 --- a/tests/baselines/reference/exportStarForValues.types +++ b/tests/baselines/reference/exportStarForValues.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues10.js b/tests/baselines/reference/exportStarForValues10.js index f7dd6e94ce5..e4314c4f7fd 100644 --- a/tests/baselines/reference/exportStarForValues10.js +++ b/tests/baselines/reference/exportStarForValues10.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues10.ts] //// //// [file0.ts] - export var v = 1; //// [file1.ts] diff --git a/tests/baselines/reference/exportStarForValues10.symbols b/tests/baselines/reference/exportStarForValues10.symbols index d1dc20f9140..96cd95e14bb 100644 --- a/tests/baselines/reference/exportStarForValues10.symbols +++ b/tests/baselines/reference/exportStarForValues10.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/file0.ts === - export var v = 1; ->v : Symbol(v, Decl(file0.ts, 1, 10)) +>v : Symbol(v, Decl(file0.ts, 0, 10)) === tests/cases/compiler/file1.ts === export interface Foo { x } diff --git a/tests/baselines/reference/exportStarForValues10.types b/tests/baselines/reference/exportStarForValues10.types index 2be6b0c7bfe..3d613a6e6d8 100644 --- a/tests/baselines/reference/exportStarForValues10.types +++ b/tests/baselines/reference/exportStarForValues10.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file0.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportStarForValues2.js b/tests/baselines/reference/exportStarForValues2.js index f18f9f1c587..f10ae1b9936 100644 --- a/tests/baselines/reference/exportStarForValues2.js +++ b/tests/baselines/reference/exportStarForValues2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues2.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues2.symbols b/tests/baselines/reference/exportStarForValues2.symbols index fe5529b0f6d..007f15147c8 100644 --- a/tests/baselines/reference/exportStarForValues2.symbols +++ b/tests/baselines/reference/exportStarForValues2.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues2.types b/tests/baselines/reference/exportStarForValues2.types index 3a92d860ef8..56c997d6c6b 100644 --- a/tests/baselines/reference/exportStarForValues2.types +++ b/tests/baselines/reference/exportStarForValues2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues3.js b/tests/baselines/reference/exportStarForValues3.js index 5ccd12f8a37..83a818a3e81 100644 --- a/tests/baselines/reference/exportStarForValues3.js +++ b/tests/baselines/reference/exportStarForValues3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues3.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues3.symbols b/tests/baselines/reference/exportStarForValues3.symbols index 5a9cc5f8d52..e83f291ced6 100644 --- a/tests/baselines/reference/exportStarForValues3.symbols +++ b/tests/baselines/reference/exportStarForValues3.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues3.types b/tests/baselines/reference/exportStarForValues3.types index 90d38d86703..928139e45d0 100644 --- a/tests/baselines/reference/exportStarForValues3.types +++ b/tests/baselines/reference/exportStarForValues3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues4.js b/tests/baselines/reference/exportStarForValues4.js index e06b5e26207..0a49e982e29 100644 --- a/tests/baselines/reference/exportStarForValues4.js +++ b/tests/baselines/reference/exportStarForValues4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues4.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues4.symbols b/tests/baselines/reference/exportStarForValues4.symbols index a6812b72952..08b93627478 100644 --- a/tests/baselines/reference/exportStarForValues4.symbols +++ b/tests/baselines/reference/exportStarForValues4.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues4.types b/tests/baselines/reference/exportStarForValues4.types index b00dd126a9c..26460330729 100644 --- a/tests/baselines/reference/exportStarForValues4.types +++ b/tests/baselines/reference/exportStarForValues4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues5.js b/tests/baselines/reference/exportStarForValues5.js index 37c8d59c91a..812058ebd06 100644 --- a/tests/baselines/reference/exportStarForValues5.js +++ b/tests/baselines/reference/exportStarForValues5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues5.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues5.symbols b/tests/baselines/reference/exportStarForValues5.symbols index 06e6a859e23..907b8e7dacf 100644 --- a/tests/baselines/reference/exportStarForValues5.symbols +++ b/tests/baselines/reference/exportStarForValues5.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues5.types b/tests/baselines/reference/exportStarForValues5.types index 9edfc88289a..148457fd8db 100644 --- a/tests/baselines/reference/exportStarForValues5.types +++ b/tests/baselines/reference/exportStarForValues5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues6.js b/tests/baselines/reference/exportStarForValues6.js index dd17fbcddb2..15c2324d205 100644 --- a/tests/baselines/reference/exportStarForValues6.js +++ b/tests/baselines/reference/exportStarForValues6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues6.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues6.symbols b/tests/baselines/reference/exportStarForValues6.symbols index 1eba5698be5..4a8fe67e927 100644 --- a/tests/baselines/reference/exportStarForValues6.symbols +++ b/tests/baselines/reference/exportStarForValues6.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues6.types b/tests/baselines/reference/exportStarForValues6.types index 3d418e2dc24..eb76ce2ca5a 100644 --- a/tests/baselines/reference/exportStarForValues6.types +++ b/tests/baselines/reference/exportStarForValues6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues7.js b/tests/baselines/reference/exportStarForValues7.js index 1f5163dd9cd..af213d13080 100644 --- a/tests/baselines/reference/exportStarForValues7.js +++ b/tests/baselines/reference/exportStarForValues7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues7.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues7.symbols b/tests/baselines/reference/exportStarForValues7.symbols index 952b7e3eff5..dfbea67d4d9 100644 --- a/tests/baselines/reference/exportStarForValues7.symbols +++ b/tests/baselines/reference/exportStarForValues7.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues7.types b/tests/baselines/reference/exportStarForValues7.types index 41927bab512..83c454faa06 100644 --- a/tests/baselines/reference/exportStarForValues7.types +++ b/tests/baselines/reference/exportStarForValues7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues8.js b/tests/baselines/reference/exportStarForValues8.js index 6f52bce89f9..7a0045c22cb 100644 --- a/tests/baselines/reference/exportStarForValues8.js +++ b/tests/baselines/reference/exportStarForValues8.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues8.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues8.symbols b/tests/baselines/reference/exportStarForValues8.symbols index 3b893dfa42b..eee82bf3545 100644 --- a/tests/baselines/reference/exportStarForValues8.symbols +++ b/tests/baselines/reference/exportStarForValues8.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues8.types b/tests/baselines/reference/exportStarForValues8.types index 7d06bd0d1f5..b4fab224436 100644 --- a/tests/baselines/reference/exportStarForValues8.types +++ b/tests/baselines/reference/exportStarForValues8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues9.js b/tests/baselines/reference/exportStarForValues9.js index 3c34bb1afdb..8eb92c05e74 100644 --- a/tests/baselines/reference/exportStarForValues9.js +++ b/tests/baselines/reference/exportStarForValues9.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues9.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues9.symbols b/tests/baselines/reference/exportStarForValues9.symbols index e311f661a00..0889ad876ee 100644 --- a/tests/baselines/reference/exportStarForValues9.symbols +++ b/tests/baselines/reference/exportStarForValues9.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues9.types b/tests/baselines/reference/exportStarForValues9.types index aa09e1f12cf..843f0a42584 100644 --- a/tests/baselines/reference/exportStarForValues9.types +++ b/tests/baselines/reference/exportStarForValues9.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValuesInSystem.js b/tests/baselines/reference/exportStarForValuesInSystem.js index 4fbd3ca0066..8cd96011199 100644 --- a/tests/baselines/reference/exportStarForValuesInSystem.js +++ b/tests/baselines/reference/exportStarForValuesInSystem.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValuesInSystem.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValuesInSystem.symbols b/tests/baselines/reference/exportStarForValuesInSystem.symbols index d4ffe0eeaa2..c2367441a73 100644 --- a/tests/baselines/reference/exportStarForValuesInSystem.symbols +++ b/tests/baselines/reference/exportStarForValuesInSystem.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValuesInSystem.types b/tests/baselines/reference/exportStarForValuesInSystem.types index bbb9a5a6b15..b914f93a98f 100644 --- a/tests/baselines/reference/exportStarForValuesInSystem.types +++ b/tests/baselines/reference/exportStarForValuesInSystem.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarFromEmptyModule.errors.txt b/tests/baselines/reference/exportStarFromEmptyModule.errors.txt index 8ca80fae408..6c5e4b58d36 100644 --- a/tests/baselines/reference/exportStarFromEmptyModule.errors.txt +++ b/tests/baselines/reference/exportStarFromEmptyModule.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/exportStarFromEmptyModule_module4.ts(4,5): error TS2339: Pr ==== tests/cases/compiler/exportStarFromEmptyModule_module1.ts (0 errors) ==== - export class A { static r; } diff --git a/tests/baselines/reference/exportStarFromEmptyModule.js b/tests/baselines/reference/exportStarFromEmptyModule.js index 4fcac9312b9..ce282722a29 100644 --- a/tests/baselines/reference/exportStarFromEmptyModule.js +++ b/tests/baselines/reference/exportStarFromEmptyModule.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarFromEmptyModule.ts] //// //// [exportStarFromEmptyModule_module1.ts] - export class A { static r; } diff --git a/tests/baselines/reference/exportsAndImports1-amd.js b/tests/baselines/reference/exportsAndImports1-amd.js index 87761c779fa..16c4a86a7c1 100644 --- a/tests/baselines/reference/exportsAndImports1-amd.js +++ b/tests/baselines/reference/exportsAndImports1-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports1-amd.ts] //// //// [t1.ts] - var v = 1; function f() { } class C { diff --git a/tests/baselines/reference/exportsAndImports1-amd.symbols b/tests/baselines/reference/exportsAndImports1-amd.symbols index dc90c8c7bf9..64db869f45d 100644 --- a/tests/baselines/reference/exportsAndImports1-amd.symbols +++ b/tests/baselines/reference/exportsAndImports1-amd.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 3)) +>v : Symbol(v, Decl(t1.ts, 0, 3)) function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 10)) +>f : Symbol(f, Decl(t1.ts, 0, 10)) class C { ->C : Symbol(C, Decl(t1.ts, 2, 16)) +>C : Symbol(C, Decl(t1.ts, 1, 16)) } interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 8)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 8)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 14)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 14)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 10)) +>I : Symbol(I, Decl(t1.ts, 15, 10)) } } type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 16)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 16)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v, f, C, I, E, D, M, N, T, a }; ->v : Symbol(v, Decl(t1.ts, 23, 8)) ->f : Symbol(f, Decl(t1.ts, 23, 11)) ->C : Symbol(C, Decl(t1.ts, 23, 14)) ->I : Symbol(I, Decl(t1.ts, 23, 17)) ->E : Symbol(E, Decl(t1.ts, 23, 20)) ->D : Symbol(D, Decl(t1.ts, 23, 23)) ->M : Symbol(M, Decl(t1.ts, 23, 26)) ->N : Symbol(N, Decl(t1.ts, 23, 29)) ->T : Symbol(T, Decl(t1.ts, 23, 32)) ->a : Symbol(a, Decl(t1.ts, 23, 35)) +>v : Symbol(v, Decl(t1.ts, 22, 8)) +>f : Symbol(f, Decl(t1.ts, 22, 11)) +>C : Symbol(C, Decl(t1.ts, 22, 14)) +>I : Symbol(I, Decl(t1.ts, 22, 17)) +>E : Symbol(E, Decl(t1.ts, 22, 20)) +>D : Symbol(D, Decl(t1.ts, 22, 23)) +>M : Symbol(M, Decl(t1.ts, 22, 26)) +>N : Symbol(N, Decl(t1.ts, 22, 29)) +>T : Symbol(T, Decl(t1.ts, 22, 32)) +>a : Symbol(a, Decl(t1.ts, 22, 35)) === tests/cases/conformance/es6/modules/t2.ts === export { v, f, C, I, E, D, M, N, T, a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports1-amd.types b/tests/baselines/reference/exportsAndImports1-amd.types index 05c8b6d7af5..3a8763fb578 100644 --- a/tests/baselines/reference/exportsAndImports1-amd.types +++ b/tests/baselines/reference/exportsAndImports1-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports1-es6.js b/tests/baselines/reference/exportsAndImports1-es6.js index 6b9a40f0ea2..71e8de6f9fa 100644 --- a/tests/baselines/reference/exportsAndImports1-es6.js +++ b/tests/baselines/reference/exportsAndImports1-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts] //// //// [t1.ts] - var v = 1; function f() { } class C { diff --git a/tests/baselines/reference/exportsAndImports1-es6.symbols b/tests/baselines/reference/exportsAndImports1-es6.symbols index dc90c8c7bf9..64db869f45d 100644 --- a/tests/baselines/reference/exportsAndImports1-es6.symbols +++ b/tests/baselines/reference/exportsAndImports1-es6.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 3)) +>v : Symbol(v, Decl(t1.ts, 0, 3)) function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 10)) +>f : Symbol(f, Decl(t1.ts, 0, 10)) class C { ->C : Symbol(C, Decl(t1.ts, 2, 16)) +>C : Symbol(C, Decl(t1.ts, 1, 16)) } interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 8)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 8)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 14)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 14)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 10)) +>I : Symbol(I, Decl(t1.ts, 15, 10)) } } type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 16)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 16)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v, f, C, I, E, D, M, N, T, a }; ->v : Symbol(v, Decl(t1.ts, 23, 8)) ->f : Symbol(f, Decl(t1.ts, 23, 11)) ->C : Symbol(C, Decl(t1.ts, 23, 14)) ->I : Symbol(I, Decl(t1.ts, 23, 17)) ->E : Symbol(E, Decl(t1.ts, 23, 20)) ->D : Symbol(D, Decl(t1.ts, 23, 23)) ->M : Symbol(M, Decl(t1.ts, 23, 26)) ->N : Symbol(N, Decl(t1.ts, 23, 29)) ->T : Symbol(T, Decl(t1.ts, 23, 32)) ->a : Symbol(a, Decl(t1.ts, 23, 35)) +>v : Symbol(v, Decl(t1.ts, 22, 8)) +>f : Symbol(f, Decl(t1.ts, 22, 11)) +>C : Symbol(C, Decl(t1.ts, 22, 14)) +>I : Symbol(I, Decl(t1.ts, 22, 17)) +>E : Symbol(E, Decl(t1.ts, 22, 20)) +>D : Symbol(D, Decl(t1.ts, 22, 23)) +>M : Symbol(M, Decl(t1.ts, 22, 26)) +>N : Symbol(N, Decl(t1.ts, 22, 29)) +>T : Symbol(T, Decl(t1.ts, 22, 32)) +>a : Symbol(a, Decl(t1.ts, 22, 35)) === tests/cases/conformance/es6/modules/t2.ts === export { v, f, C, I, E, D, M, N, T, a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports1-es6.types b/tests/baselines/reference/exportsAndImports1-es6.types index 05c8b6d7af5..3a8763fb578 100644 --- a/tests/baselines/reference/exportsAndImports1-es6.types +++ b/tests/baselines/reference/exportsAndImports1-es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports1.js b/tests/baselines/reference/exportsAndImports1.js index 56f74d27473..30fef6e7ccf 100644 --- a/tests/baselines/reference/exportsAndImports1.js +++ b/tests/baselines/reference/exportsAndImports1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports1.ts] //// //// [t1.ts] - var v = 1; function f() { } class C { diff --git a/tests/baselines/reference/exportsAndImports1.symbols b/tests/baselines/reference/exportsAndImports1.symbols index dc90c8c7bf9..64db869f45d 100644 --- a/tests/baselines/reference/exportsAndImports1.symbols +++ b/tests/baselines/reference/exportsAndImports1.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 3)) +>v : Symbol(v, Decl(t1.ts, 0, 3)) function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 10)) +>f : Symbol(f, Decl(t1.ts, 0, 10)) class C { ->C : Symbol(C, Decl(t1.ts, 2, 16)) +>C : Symbol(C, Decl(t1.ts, 1, 16)) } interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 8)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 8)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 14)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 14)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 10)) +>I : Symbol(I, Decl(t1.ts, 15, 10)) } } type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 16)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 16)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v, f, C, I, E, D, M, N, T, a }; ->v : Symbol(v, Decl(t1.ts, 23, 8)) ->f : Symbol(f, Decl(t1.ts, 23, 11)) ->C : Symbol(C, Decl(t1.ts, 23, 14)) ->I : Symbol(I, Decl(t1.ts, 23, 17)) ->E : Symbol(E, Decl(t1.ts, 23, 20)) ->D : Symbol(D, Decl(t1.ts, 23, 23)) ->M : Symbol(M, Decl(t1.ts, 23, 26)) ->N : Symbol(N, Decl(t1.ts, 23, 29)) ->T : Symbol(T, Decl(t1.ts, 23, 32)) ->a : Symbol(a, Decl(t1.ts, 23, 35)) +>v : Symbol(v, Decl(t1.ts, 22, 8)) +>f : Symbol(f, Decl(t1.ts, 22, 11)) +>C : Symbol(C, Decl(t1.ts, 22, 14)) +>I : Symbol(I, Decl(t1.ts, 22, 17)) +>E : Symbol(E, Decl(t1.ts, 22, 20)) +>D : Symbol(D, Decl(t1.ts, 22, 23)) +>M : Symbol(M, Decl(t1.ts, 22, 26)) +>N : Symbol(N, Decl(t1.ts, 22, 29)) +>T : Symbol(T, Decl(t1.ts, 22, 32)) +>a : Symbol(a, Decl(t1.ts, 22, 35)) === tests/cases/conformance/es6/modules/t2.ts === export { v, f, C, I, E, D, M, N, T, a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports1.types b/tests/baselines/reference/exportsAndImports1.types index 05c8b6d7af5..3a8763fb578 100644 --- a/tests/baselines/reference/exportsAndImports1.types +++ b/tests/baselines/reference/exportsAndImports1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports2-amd.js b/tests/baselines/reference/exportsAndImports2-amd.js index 5154751b21e..04685dcaa33 100644 --- a/tests/baselines/reference/exportsAndImports2-amd.js +++ b/tests/baselines/reference/exportsAndImports2-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports2-amd.ts] //// //// [t1.ts] - export var x = "x"; export var y = "y"; diff --git a/tests/baselines/reference/exportsAndImports2-amd.symbols b/tests/baselines/reference/exportsAndImports2-amd.symbols index 8b53794abae..293755a8005 100644 --- a/tests/baselines/reference/exportsAndImports2-amd.symbols +++ b/tests/baselines/reference/exportsAndImports2-amd.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) export var y = "y"; ->y : Symbol(y, Decl(t1.ts, 2, 10)) +>y : Symbol(y, Decl(t1.ts, 1, 10)) === tests/cases/conformance/es6/modules/t2.ts === export { x as y, y as x } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports2-amd.types b/tests/baselines/reference/exportsAndImports2-amd.types index 46e42174a77..0f5614794e3 100644 --- a/tests/baselines/reference/exportsAndImports2-amd.types +++ b/tests/baselines/reference/exportsAndImports2-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportsAndImports2-es6.js b/tests/baselines/reference/exportsAndImports2-es6.js index b0714b83c39..2a57a43f1a5 100644 --- a/tests/baselines/reference/exportsAndImports2-es6.js +++ b/tests/baselines/reference/exportsAndImports2-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts] //// //// [t1.ts] - export var x = "x"; export var y = "y"; diff --git a/tests/baselines/reference/exportsAndImports2-es6.symbols b/tests/baselines/reference/exportsAndImports2-es6.symbols index 8b53794abae..293755a8005 100644 --- a/tests/baselines/reference/exportsAndImports2-es6.symbols +++ b/tests/baselines/reference/exportsAndImports2-es6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) export var y = "y"; ->y : Symbol(y, Decl(t1.ts, 2, 10)) +>y : Symbol(y, Decl(t1.ts, 1, 10)) === tests/cases/conformance/es6/modules/t2.ts === export { x as y, y as x } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports2-es6.types b/tests/baselines/reference/exportsAndImports2-es6.types index 46e42174a77..0f5614794e3 100644 --- a/tests/baselines/reference/exportsAndImports2-es6.types +++ b/tests/baselines/reference/exportsAndImports2-es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportsAndImports2.js b/tests/baselines/reference/exportsAndImports2.js index 5b3fe689d90..d905ab3827f 100644 --- a/tests/baselines/reference/exportsAndImports2.js +++ b/tests/baselines/reference/exportsAndImports2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports2.ts] //// //// [t1.ts] - export var x = "x"; export var y = "y"; diff --git a/tests/baselines/reference/exportsAndImports2.symbols b/tests/baselines/reference/exportsAndImports2.symbols index 8b53794abae..293755a8005 100644 --- a/tests/baselines/reference/exportsAndImports2.symbols +++ b/tests/baselines/reference/exportsAndImports2.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) export var y = "y"; ->y : Symbol(y, Decl(t1.ts, 2, 10)) +>y : Symbol(y, Decl(t1.ts, 1, 10)) === tests/cases/conformance/es6/modules/t2.ts === export { x as y, y as x } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports2.types b/tests/baselines/reference/exportsAndImports2.types index 46e42174a77..0f5614794e3 100644 --- a/tests/baselines/reference/exportsAndImports2.types +++ b/tests/baselines/reference/exportsAndImports2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportsAndImports3-amd.js b/tests/baselines/reference/exportsAndImports3-amd.js index a6af4adb5f4..87dc8d03ab8 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.js +++ b/tests/baselines/reference/exportsAndImports3-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports3-amd.ts] //// //// [t1.ts] - export var v = 1; export function f() { } export class C { diff --git a/tests/baselines/reference/exportsAndImports3-amd.symbols b/tests/baselines/reference/exportsAndImports3-amd.symbols index a46d7df2a68..f71014281c2 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.symbols +++ b/tests/baselines/reference/exportsAndImports3-amd.symbols @@ -1,75 +1,74 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 10)) +>v : Symbol(v, Decl(t1.ts, 0, 10)) export function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 17)) +>f : Symbol(f, Decl(t1.ts, 0, 17)) export class C { ->C : Symbol(C, Decl(t1.ts, 2, 23)) +>C : Symbol(C, Decl(t1.ts, 1, 23)) } export interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } export enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 15)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } export const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 21)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } export module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } export module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 17)) +>I : Symbol(I, Decl(t1.ts, 15, 17)) } } export type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) export import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 23)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 23)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 }; ->v : Symbol(v1, Decl(t1.ts, 23, 8)) ->v1 : Symbol(v1, Decl(t1.ts, 23, 8)) ->f : Symbol(f1, Decl(t1.ts, 23, 17)) ->f1 : Symbol(f1, Decl(t1.ts, 23, 17)) ->C : Symbol(C1, Decl(t1.ts, 23, 26)) ->C1 : Symbol(C1, Decl(t1.ts, 23, 26)) ->I : Symbol(I1, Decl(t1.ts, 23, 35)) ->I1 : Symbol(I1, Decl(t1.ts, 23, 35)) ->E : Symbol(E1, Decl(t1.ts, 23, 44)) ->E1 : Symbol(E1, Decl(t1.ts, 23, 44)) ->D : Symbol(D1, Decl(t1.ts, 23, 53)) ->D1 : Symbol(D1, Decl(t1.ts, 23, 53)) ->M : Symbol(M1, Decl(t1.ts, 23, 62)) ->M1 : Symbol(M1, Decl(t1.ts, 23, 62)) ->N : Symbol(N1, Decl(t1.ts, 23, 71)) ->N1 : Symbol(N1, Decl(t1.ts, 23, 71)) ->T : Symbol(T1, Decl(t1.ts, 23, 80)) ->T1 : Symbol(T1, Decl(t1.ts, 23, 80)) ->a : Symbol(a1, Decl(t1.ts, 23, 89)) ->a1 : Symbol(a1, Decl(t1.ts, 23, 89)) +>v : Symbol(v1, Decl(t1.ts, 22, 8)) +>v1 : Symbol(v1, Decl(t1.ts, 22, 8)) +>f : Symbol(f1, Decl(t1.ts, 22, 17)) +>f1 : Symbol(f1, Decl(t1.ts, 22, 17)) +>C : Symbol(C1, Decl(t1.ts, 22, 26)) +>C1 : Symbol(C1, Decl(t1.ts, 22, 26)) +>I : Symbol(I1, Decl(t1.ts, 22, 35)) +>I1 : Symbol(I1, Decl(t1.ts, 22, 35)) +>E : Symbol(E1, Decl(t1.ts, 22, 44)) +>E1 : Symbol(E1, Decl(t1.ts, 22, 44)) +>D : Symbol(D1, Decl(t1.ts, 22, 53)) +>D1 : Symbol(D1, Decl(t1.ts, 22, 53)) +>M : Symbol(M1, Decl(t1.ts, 22, 62)) +>M1 : Symbol(M1, Decl(t1.ts, 22, 62)) +>N : Symbol(N1, Decl(t1.ts, 22, 71)) +>N1 : Symbol(N1, Decl(t1.ts, 22, 71)) +>T : Symbol(T1, Decl(t1.ts, 22, 80)) +>T1 : Symbol(T1, Decl(t1.ts, 22, 80)) +>a : Symbol(a1, Decl(t1.ts, 22, 89)) +>a1 : Symbol(a1, Decl(t1.ts, 22, 89)) === tests/cases/conformance/es6/modules/t2.ts === export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports3-amd.types b/tests/baselines/reference/exportsAndImports3-amd.types index 5292f01af0d..afb32cb9c54 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.types +++ b/tests/baselines/reference/exportsAndImports3-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports3-es6.js b/tests/baselines/reference/exportsAndImports3-es6.js index 1ac23446807..54122371777 100644 --- a/tests/baselines/reference/exportsAndImports3-es6.js +++ b/tests/baselines/reference/exportsAndImports3-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts] //// //// [t1.ts] - export var v = 1; export function f() { } export class C { diff --git a/tests/baselines/reference/exportsAndImports3-es6.symbols b/tests/baselines/reference/exportsAndImports3-es6.symbols index a46d7df2a68..f71014281c2 100644 --- a/tests/baselines/reference/exportsAndImports3-es6.symbols +++ b/tests/baselines/reference/exportsAndImports3-es6.symbols @@ -1,75 +1,74 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 10)) +>v : Symbol(v, Decl(t1.ts, 0, 10)) export function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 17)) +>f : Symbol(f, Decl(t1.ts, 0, 17)) export class C { ->C : Symbol(C, Decl(t1.ts, 2, 23)) +>C : Symbol(C, Decl(t1.ts, 1, 23)) } export interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } export enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 15)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } export const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 21)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } export module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } export module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 17)) +>I : Symbol(I, Decl(t1.ts, 15, 17)) } } export type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) export import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 23)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 23)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 }; ->v : Symbol(v1, Decl(t1.ts, 23, 8)) ->v1 : Symbol(v1, Decl(t1.ts, 23, 8)) ->f : Symbol(f1, Decl(t1.ts, 23, 17)) ->f1 : Symbol(f1, Decl(t1.ts, 23, 17)) ->C : Symbol(C1, Decl(t1.ts, 23, 26)) ->C1 : Symbol(C1, Decl(t1.ts, 23, 26)) ->I : Symbol(I1, Decl(t1.ts, 23, 35)) ->I1 : Symbol(I1, Decl(t1.ts, 23, 35)) ->E : Symbol(E1, Decl(t1.ts, 23, 44)) ->E1 : Symbol(E1, Decl(t1.ts, 23, 44)) ->D : Symbol(D1, Decl(t1.ts, 23, 53)) ->D1 : Symbol(D1, Decl(t1.ts, 23, 53)) ->M : Symbol(M1, Decl(t1.ts, 23, 62)) ->M1 : Symbol(M1, Decl(t1.ts, 23, 62)) ->N : Symbol(N1, Decl(t1.ts, 23, 71)) ->N1 : Symbol(N1, Decl(t1.ts, 23, 71)) ->T : Symbol(T1, Decl(t1.ts, 23, 80)) ->T1 : Symbol(T1, Decl(t1.ts, 23, 80)) ->a : Symbol(a1, Decl(t1.ts, 23, 89)) ->a1 : Symbol(a1, Decl(t1.ts, 23, 89)) +>v : Symbol(v1, Decl(t1.ts, 22, 8)) +>v1 : Symbol(v1, Decl(t1.ts, 22, 8)) +>f : Symbol(f1, Decl(t1.ts, 22, 17)) +>f1 : Symbol(f1, Decl(t1.ts, 22, 17)) +>C : Symbol(C1, Decl(t1.ts, 22, 26)) +>C1 : Symbol(C1, Decl(t1.ts, 22, 26)) +>I : Symbol(I1, Decl(t1.ts, 22, 35)) +>I1 : Symbol(I1, Decl(t1.ts, 22, 35)) +>E : Symbol(E1, Decl(t1.ts, 22, 44)) +>E1 : Symbol(E1, Decl(t1.ts, 22, 44)) +>D : Symbol(D1, Decl(t1.ts, 22, 53)) +>D1 : Symbol(D1, Decl(t1.ts, 22, 53)) +>M : Symbol(M1, Decl(t1.ts, 22, 62)) +>M1 : Symbol(M1, Decl(t1.ts, 22, 62)) +>N : Symbol(N1, Decl(t1.ts, 22, 71)) +>N1 : Symbol(N1, Decl(t1.ts, 22, 71)) +>T : Symbol(T1, Decl(t1.ts, 22, 80)) +>T1 : Symbol(T1, Decl(t1.ts, 22, 80)) +>a : Symbol(a1, Decl(t1.ts, 22, 89)) +>a1 : Symbol(a1, Decl(t1.ts, 22, 89)) === tests/cases/conformance/es6/modules/t2.ts === export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports3-es6.types b/tests/baselines/reference/exportsAndImports3-es6.types index 5292f01af0d..afb32cb9c54 100644 --- a/tests/baselines/reference/exportsAndImports3-es6.types +++ b/tests/baselines/reference/exportsAndImports3-es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports3.js b/tests/baselines/reference/exportsAndImports3.js index 4dfa0411946..77ac28f4800 100644 --- a/tests/baselines/reference/exportsAndImports3.js +++ b/tests/baselines/reference/exportsAndImports3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports3.ts] //// //// [t1.ts] - export var v = 1; export function f() { } export class C { diff --git a/tests/baselines/reference/exportsAndImports3.symbols b/tests/baselines/reference/exportsAndImports3.symbols index a46d7df2a68..f71014281c2 100644 --- a/tests/baselines/reference/exportsAndImports3.symbols +++ b/tests/baselines/reference/exportsAndImports3.symbols @@ -1,75 +1,74 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 10)) +>v : Symbol(v, Decl(t1.ts, 0, 10)) export function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 17)) +>f : Symbol(f, Decl(t1.ts, 0, 17)) export class C { ->C : Symbol(C, Decl(t1.ts, 2, 23)) +>C : Symbol(C, Decl(t1.ts, 1, 23)) } export interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } export enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 15)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } export const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 21)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } export module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } export module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 17)) +>I : Symbol(I, Decl(t1.ts, 15, 17)) } } export type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) export import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 23)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 23)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 }; ->v : Symbol(v1, Decl(t1.ts, 23, 8)) ->v1 : Symbol(v1, Decl(t1.ts, 23, 8)) ->f : Symbol(f1, Decl(t1.ts, 23, 17)) ->f1 : Symbol(f1, Decl(t1.ts, 23, 17)) ->C : Symbol(C1, Decl(t1.ts, 23, 26)) ->C1 : Symbol(C1, Decl(t1.ts, 23, 26)) ->I : Symbol(I1, Decl(t1.ts, 23, 35)) ->I1 : Symbol(I1, Decl(t1.ts, 23, 35)) ->E : Symbol(E1, Decl(t1.ts, 23, 44)) ->E1 : Symbol(E1, Decl(t1.ts, 23, 44)) ->D : Symbol(D1, Decl(t1.ts, 23, 53)) ->D1 : Symbol(D1, Decl(t1.ts, 23, 53)) ->M : Symbol(M1, Decl(t1.ts, 23, 62)) ->M1 : Symbol(M1, Decl(t1.ts, 23, 62)) ->N : Symbol(N1, Decl(t1.ts, 23, 71)) ->N1 : Symbol(N1, Decl(t1.ts, 23, 71)) ->T : Symbol(T1, Decl(t1.ts, 23, 80)) ->T1 : Symbol(T1, Decl(t1.ts, 23, 80)) ->a : Symbol(a1, Decl(t1.ts, 23, 89)) ->a1 : Symbol(a1, Decl(t1.ts, 23, 89)) +>v : Symbol(v1, Decl(t1.ts, 22, 8)) +>v1 : Symbol(v1, Decl(t1.ts, 22, 8)) +>f : Symbol(f1, Decl(t1.ts, 22, 17)) +>f1 : Symbol(f1, Decl(t1.ts, 22, 17)) +>C : Symbol(C1, Decl(t1.ts, 22, 26)) +>C1 : Symbol(C1, Decl(t1.ts, 22, 26)) +>I : Symbol(I1, Decl(t1.ts, 22, 35)) +>I1 : Symbol(I1, Decl(t1.ts, 22, 35)) +>E : Symbol(E1, Decl(t1.ts, 22, 44)) +>E1 : Symbol(E1, Decl(t1.ts, 22, 44)) +>D : Symbol(D1, Decl(t1.ts, 22, 53)) +>D1 : Symbol(D1, Decl(t1.ts, 22, 53)) +>M : Symbol(M1, Decl(t1.ts, 22, 62)) +>M1 : Symbol(M1, Decl(t1.ts, 22, 62)) +>N : Symbol(N1, Decl(t1.ts, 22, 71)) +>N1 : Symbol(N1, Decl(t1.ts, 22, 71)) +>T : Symbol(T1, Decl(t1.ts, 22, 80)) +>T1 : Symbol(T1, Decl(t1.ts, 22, 80)) +>a : Symbol(a1, Decl(t1.ts, 22, 89)) +>a1 : Symbol(a1, Decl(t1.ts, 22, 89)) === tests/cases/conformance/es6/modules/t2.ts === export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports3.types b/tests/baselines/reference/exportsAndImports3.types index 5292f01af0d..afb32cb9c54 100644 --- a/tests/baselines/reference/exportsAndImports3.types +++ b/tests/baselines/reference/exportsAndImports3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports4-amd.js b/tests/baselines/reference/exportsAndImports4-amd.js index ed31f42ebc7..52a41a0a451 100644 --- a/tests/baselines/reference/exportsAndImports4-amd.js +++ b/tests/baselines/reference/exportsAndImports4-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports4-amd.ts] //// //// [t1.ts] - export default "hello"; //// [t2.ts] diff --git a/tests/baselines/reference/exportsAndImports4-amd.symbols b/tests/baselines/reference/exportsAndImports4-amd.symbols index 0204d9bd586..ed522576398 100644 --- a/tests/baselines/reference/exportsAndImports4-amd.symbols +++ b/tests/baselines/reference/exportsAndImports4-amd.symbols @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : Symbol(f2, Decl(t3.ts, 14, 32)) === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4-amd.types b/tests/baselines/reference/exportsAndImports4-amd.types index dfddd897e59..6127765014a 100644 --- a/tests/baselines/reference/exportsAndImports4-amd.types +++ b/tests/baselines/reference/exportsAndImports4-amd.types @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : "hello" === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4-es6.js b/tests/baselines/reference/exportsAndImports4-es6.js index d8c51d03bb1..ee35571942f 100644 --- a/tests/baselines/reference/exportsAndImports4-es6.js +++ b/tests/baselines/reference/exportsAndImports4-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts] //// //// [t1.ts] - export default "hello"; //// [t2.ts] diff --git a/tests/baselines/reference/exportsAndImports4-es6.symbols b/tests/baselines/reference/exportsAndImports4-es6.symbols index 0204d9bd586..ed522576398 100644 --- a/tests/baselines/reference/exportsAndImports4-es6.symbols +++ b/tests/baselines/reference/exportsAndImports4-es6.symbols @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : Symbol(f2, Decl(t3.ts, 14, 32)) === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4-es6.types b/tests/baselines/reference/exportsAndImports4-es6.types index dfddd897e59..6127765014a 100644 --- a/tests/baselines/reference/exportsAndImports4-es6.types +++ b/tests/baselines/reference/exportsAndImports4-es6.types @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : "hello" === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4.js b/tests/baselines/reference/exportsAndImports4.js index 99f81a6b875..efb93eeebf6 100644 --- a/tests/baselines/reference/exportsAndImports4.js +++ b/tests/baselines/reference/exportsAndImports4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports4.ts] //// //// [t1.ts] - export default "hello"; //// [t2.ts] diff --git a/tests/baselines/reference/exportsAndImports4.symbols b/tests/baselines/reference/exportsAndImports4.symbols index 0204d9bd586..ed522576398 100644 --- a/tests/baselines/reference/exportsAndImports4.symbols +++ b/tests/baselines/reference/exportsAndImports4.symbols @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : Symbol(f2, Decl(t3.ts, 14, 32)) === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4.types b/tests/baselines/reference/exportsAndImports4.types index dfddd897e59..6127765014a 100644 --- a/tests/baselines/reference/exportsAndImports4.types +++ b/tests/baselines/reference/exportsAndImports4.types @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : "hello" === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt index 6d443464d99..767af3d75be 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt @@ -2,7 +2,6 @@ tests/cases/conformance/es6/modules/t3.ts(1,17): error TS1214: Identifier expect ==== tests/cases/conformance/es6/modules/t1.ts (0 errors) ==== - let set = { set foo(x: number) { } diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js index 068afdc346b..1cd4fee3c79 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithContextualKeywordNames01.ts] //// //// [t1.ts] - let set = { set foo(x: number) { } diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js index 8b1deff064f..cf1976e5b03 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithContextualKeywordNames02.ts] //// //// [t1.ts] - let as = 100; export { as as return, as }; diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols index 4bc53e9d4b6..a8945c88cc6 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/modules/t1.ts === - let as = 100; ->as : Symbol(as, Decl(t1.ts, 1, 3)) +>as : Symbol(as, Decl(t1.ts, 0, 3)) export { as as return, as }; ->as : Symbol(return, Decl(t1.ts, 3, 8)) ->return : Symbol(return, Decl(t1.ts, 3, 8)) ->as : Symbol(as, Decl(t1.ts, 3, 22)) +>as : Symbol(return, Decl(t1.ts, 2, 8)) +>return : Symbol(return, Decl(t1.ts, 2, 8)) +>as : Symbol(as, Decl(t1.ts, 2, 22)) === tests/cases/conformance/es6/modules/t2.ts === import * as as from "./t1"; @@ -14,15 +13,15 @@ import * as as from "./t1"; var x = as.as; >x : Symbol(x, Decl(t2.ts, 1, 3)) ->as.as : Symbol(as.as, Decl(t1.ts, 3, 22)) +>as.as : Symbol(as.as, Decl(t1.ts, 2, 22)) >as : Symbol(as, Decl(t2.ts, 0, 6)) ->as : Symbol(as.as, Decl(t1.ts, 3, 22)) +>as : Symbol(as.as, Decl(t1.ts, 2, 22)) var y = as.return; >y : Symbol(y, Decl(t2.ts, 2, 3)) ->as.return : Symbol(as.return, Decl(t1.ts, 3, 8)) +>as.return : Symbol(as.return, Decl(t1.ts, 2, 8)) >as : Symbol(as, Decl(t2.ts, 0, 6)) ->return : Symbol(as.return, Decl(t1.ts, 3, 8)) +>return : Symbol(as.return, Decl(t1.ts, 2, 8)) === tests/cases/conformance/es6/modules/t3.ts === import { as as as } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types index c12e84e320b..5bffab447e9 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - let as = 100; >as : number >100 : 100 diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt b/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt index 7a65dd62c2b..33d15265cb9 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/modules/m1.ts(6,5): error TS1005: ',' expected. +tests/cases/conformance/es6/modules/m1.ts(5,5): error TS1005: ',' expected. ==== tests/cases/conformance/es6/modules/m1.ts (1 errors) ==== - var R: any export default R = { "__": 20, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores1.js b/tests/baselines/reference/exportsAndImportsWithUnderscores1.js index 207d2948fa4..284537252fe 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores1.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores1.ts] //// //// [m1.ts] - var R: any export default R = { "__": 20, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores2.js b/tests/baselines/reference/exportsAndImportsWithUnderscores2.js index a53d4662e97..90cbc11b95b 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores2.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores2.ts] //// //// [m1.ts] - var R: any export default R = { "__esmodule": true, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols b/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols index d5f5ef17a62..7121472886a 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) export default R = { ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) "__esmodule": true, "__proto__": {} diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores2.types b/tests/baselines/reference/exportsAndImportsWithUnderscores2.types index 3b86789cc44..e38209b842f 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores2.types +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any >R : any diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores3.js b/tests/baselines/reference/exportsAndImportsWithUnderscores3.js index 3a5bba1deed..0aead5f1f8b 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores3.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores3.ts] //// //// [m1.ts] - var R: any export default R = { "___": 30, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols b/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols index cd4ba38e8c9..c58f1a11f76 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) export default R = { ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) "___": 30, "___hello": 21, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores3.types b/tests/baselines/reference/exportsAndImportsWithUnderscores3.types index b860928aa62..0e6bb895237 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores3.types +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any >R : any diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores4.js b/tests/baselines/reference/exportsAndImportsWithUnderscores4.js index 718d048b9a2..ad50ca41eff 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores4.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores4.ts] //// //// [m1.ts] - declare var console: any; export function _() { console.log("_"); diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols b/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols index a8fb3f307b5..075b5a80862 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols @@ -1,49 +1,48 @@ === tests/cases/conformance/es6/modules/m1.ts === - declare var console: any; ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) export function _() { ->_ : Symbol(_, Decl(m1.ts, 1, 25)) +>_ : Symbol(_, Decl(m1.ts, 0, 25)) console.log("_"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function __() { ->__ : Symbol(__, Decl(m1.ts, 4, 1)) +>__ : Symbol(__, Decl(m1.ts, 3, 1)) console.log("__"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function ___() { ->___ : Symbol(___, Decl(m1.ts, 7, 1)) +>___ : Symbol(___, Decl(m1.ts, 6, 1)) console.log("___"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function _hi() { ->_hi : Symbol(_hi, Decl(m1.ts, 10, 1)) +>_hi : Symbol(_hi, Decl(m1.ts, 9, 1)) console.log("_hi"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function __proto() { ->__proto : Symbol(__proto, Decl(m1.ts, 13, 1)) +>__proto : Symbol(__proto, Decl(m1.ts, 12, 1)) console.log("__proto"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function __esmodule() { ->__esmodule : Symbol(__esmodule, Decl(m1.ts, 16, 1)) +>__esmodule : Symbol(__esmodule, Decl(m1.ts, 15, 1)) console.log("__esmodule"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function ___hello(){ ->___hello : Symbol(___hello, Decl(m1.ts, 19, 1)) +>___hello : Symbol(___hello, Decl(m1.ts, 18, 1)) console.log("___hello"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } === tests/cases/conformance/es6/modules/m2.ts === diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores4.types b/tests/baselines/reference/exportsAndImportsWithUnderscores4.types index cf339db5dee..7fb5a0b3c88 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores4.types +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - declare var console: any; >console : any diff --git a/tests/baselines/reference/exportsInAmbientModules1.js b/tests/baselines/reference/exportsInAmbientModules1.js index 4370b197403..cc9d62cd7da 100644 --- a/tests/baselines/reference/exportsInAmbientModules1.js +++ b/tests/baselines/reference/exportsInAmbientModules1.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/exportsInAmbientModules1.ts] //// //// [external.d.ts] - export var x: number //// [main.ts] - declare module "M" { export {x} from "external" } diff --git a/tests/baselines/reference/exportsInAmbientModules1.symbols b/tests/baselines/reference/exportsInAmbientModules1.symbols index 58cdf8663a7..eee96af50f9 100644 --- a/tests/baselines/reference/exportsInAmbientModules1.symbols +++ b/tests/baselines/reference/exportsInAmbientModules1.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export var x: number ->x : Symbol(x, Decl(external.d.ts, 1, 10)) +>x : Symbol(x, Decl(external.d.ts, 0, 10)) === tests/cases/compiler/main.ts === - declare module "M" { export {x} from "external" ->x : Symbol(x, Decl(main.ts, 2, 12)) +>x : Symbol(x, Decl(main.ts, 1, 12)) } diff --git a/tests/baselines/reference/exportsInAmbientModules1.types b/tests/baselines/reference/exportsInAmbientModules1.types index 490a63caf92..4d0c1cbd26e 100644 --- a/tests/baselines/reference/exportsInAmbientModules1.types +++ b/tests/baselines/reference/exportsInAmbientModules1.types @@ -1,10 +1,8 @@ === tests/cases/compiler/external.d.ts === - export var x: number >x : number === tests/cases/compiler/main.ts === - declare module "M" { export {x} from "external" >x : number diff --git a/tests/baselines/reference/exportsInAmbientModules2.js b/tests/baselines/reference/exportsInAmbientModules2.js index f08ff17f8ba..d7ecccaebe1 100644 --- a/tests/baselines/reference/exportsInAmbientModules2.js +++ b/tests/baselines/reference/exportsInAmbientModules2.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/exportsInAmbientModules2.ts] //// //// [external.d.ts] - export default class C {} //// [main.ts] - declare module "M" { export * from "external" } diff --git a/tests/baselines/reference/exportsInAmbientModules2.symbols b/tests/baselines/reference/exportsInAmbientModules2.symbols index 54e8b44ec34..3cad91fab62 100644 --- a/tests/baselines/reference/exportsInAmbientModules2.symbols +++ b/tests/baselines/reference/exportsInAmbientModules2.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : Symbol(C, Decl(external.d.ts, 0, 0)) === tests/cases/compiler/main.ts === - -No type information for this code.declare module "M" { +declare module "M" { No type information for this code. export * from "external" No type information for this code.} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsInAmbientModules2.types b/tests/baselines/reference/exportsInAmbientModules2.types index 3472a35bf75..0c32c1c62a8 100644 --- a/tests/baselines/reference/exportsInAmbientModules2.types +++ b/tests/baselines/reference/exportsInAmbientModules2.types @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : C === tests/cases/compiler/main.ts === - -No type information for this code.declare module "M" { +declare module "M" { No type information for this code. export * from "external" No type information for this code.} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt b/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt index 7825345a1b5..a1db92b4e46 100644 --- a/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt +++ b/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt @@ -10,7 +10,6 @@ tests/cases/compiler/externalModuleExportingGenericClass_file1.ts(2,8): error TS var v3: number = (new a()).foo; ==== tests/cases/compiler/externalModuleExportingGenericClass_file0.ts (0 errors) ==== - class C { foo: T; } diff --git a/tests/baselines/reference/externalModuleExportingGenericClass.js b/tests/baselines/reference/externalModuleExportingGenericClass.js index 33aa1776e94..339eaec2cbf 100644 --- a/tests/baselines/reference/externalModuleExportingGenericClass.js +++ b/tests/baselines/reference/externalModuleExportingGenericClass.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/externalModuleExportingGenericClass.ts] //// //// [externalModuleExportingGenericClass_file0.ts] - class C { foo: T; } diff --git a/tests/baselines/reference/externalModuleImmutableBindings.errors.txt b/tests/baselines/reference/externalModuleImmutableBindings.errors.txt index 815b5847458..58e411e1035 100644 --- a/tests/baselines/reference/externalModuleImmutableBindings.errors.txt +++ b/tests/baselines/reference/externalModuleImmutableBindings.errors.txt @@ -1,32 +1,31 @@ +tests/cases/compiler/f2.ts(6,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(7,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(8,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(9,7): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(8,7): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(11,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(12,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(13,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(16,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(17,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(18,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(19,8): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(18,8): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(21,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(22,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(23,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(26,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(27,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(28,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(29,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(30,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(30,12): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. tests/cases/compiler/f2.ts(31,12): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. -tests/cases/compiler/f2.ts(32,12): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(35,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(36,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(37,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(38,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(39,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(39,13): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. tests/cases/compiler/f2.ts(40,13): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. -tests/cases/compiler/f2.ts(41,13): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. ==== tests/cases/compiler/f1.ts (0 errors) ==== export var x = 1; ==== tests/cases/compiler/f2.ts (22 errors) ==== - // all mutations below are illegal and should be fixed import * as stuff from './f1'; diff --git a/tests/baselines/reference/externalModuleImmutableBindings.js b/tests/baselines/reference/externalModuleImmutableBindings.js index 7e2a78a4728..d6f5913f5d1 100644 --- a/tests/baselines/reference/externalModuleImmutableBindings.js +++ b/tests/baselines/reference/externalModuleImmutableBindings.js @@ -4,7 +4,6 @@ export var x = 1; //// [f2.ts] - // all mutations below are illegal and should be fixed import * as stuff from './f1'; diff --git a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js index fa98fbe2223..972b4b3b2ea 100644 --- a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js +++ b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js @@ -1,5 +1,4 @@ //// [externalModuleWithoutCompilerFlag1.ts] - // Not on line 0 because we want to verify the error is placed in the appropriate location. export module M { } diff --git a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols index 21426e15e5d..0abc0ec0bda 100644 --- a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols +++ b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/externalModuleWithoutCompilerFlag1.ts === - // Not on line 0 because we want to verify the error is placed in the appropriate location. export module M { >M : Symbol(M, Decl(externalModuleWithoutCompilerFlag1.ts, 0, 0)) diff --git a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types index 26d360d63a9..39d1f7c2612 100644 --- a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types +++ b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/externalModuleWithoutCompilerFlag1.ts === - // Not on line 0 because we want to verify the error is placed in the appropriate location. export module M { >M : any diff --git a/tests/baselines/reference/fallFromLastCase1.js b/tests/baselines/reference/fallFromLastCase1.js index 3c2461db514..717762eee88 100644 --- a/tests/baselines/reference/fallFromLastCase1.js +++ b/tests/baselines/reference/fallFromLastCase1.js @@ -1,5 +1,4 @@ //// [fallFromLastCase1.ts] - declare function use(a: string); function foo1(a: number) { diff --git a/tests/baselines/reference/fallFromLastCase1.symbols b/tests/baselines/reference/fallFromLastCase1.symbols index c4967e5e775..711374a9a96 100644 --- a/tests/baselines/reference/fallFromLastCase1.symbols +++ b/tests/baselines/reference/fallFromLastCase1.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/fallFromLastCase1.ts === - declare function use(a: string); >use : Symbol(use, Decl(fallFromLastCase1.ts, 0, 0)) ->a : Symbol(a, Decl(fallFromLastCase1.ts, 1, 21)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 0, 21)) function foo1(a: number) { ->foo1 : Symbol(foo1, Decl(fallFromLastCase1.ts, 1, 32)) ->a : Symbol(a, Decl(fallFromLastCase1.ts, 3, 14)) +>foo1 : Symbol(foo1, Decl(fallFromLastCase1.ts, 0, 32)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 2, 14)) switch (a) { ->a : Symbol(a, Decl(fallFromLastCase1.ts, 3, 14)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 2, 14)) case 1: use("1"); @@ -24,11 +23,11 @@ function foo1(a: number) { function foo2(a: number) { ->foo2 : Symbol(foo2, Decl(fallFromLastCase1.ts, 11, 1)) ->a : Symbol(a, Decl(fallFromLastCase1.ts, 14, 14)) +>foo2 : Symbol(foo2, Decl(fallFromLastCase1.ts, 10, 1)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 13, 14)) switch (a) { ->a : Symbol(a, Decl(fallFromLastCase1.ts, 14, 14)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 13, 14)) case 1: use("1"); diff --git a/tests/baselines/reference/fallFromLastCase1.types b/tests/baselines/reference/fallFromLastCase1.types index 0353ae88387..b67bf9e0bbd 100644 --- a/tests/baselines/reference/fallFromLastCase1.types +++ b/tests/baselines/reference/fallFromLastCase1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/fallFromLastCase1.ts === - declare function use(a: string); >use : (a: string) => any >a : string diff --git a/tests/baselines/reference/fallFromLastCase2.errors.txt b/tests/baselines/reference/fallFromLastCase2.errors.txt index ccf7f6ebc1b..fcf3251ac3f 100644 --- a/tests/baselines/reference/fallFromLastCase2.errors.txt +++ b/tests/baselines/reference/fallFromLastCase2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/fallFromLastCase2.ts(9,9): error TS7029: Fallthrough case in switch. -tests/cases/compiler/fallFromLastCase2.ts(22,9): error TS7029: Fallthrough case in switch. +tests/cases/compiler/fallFromLastCase2.ts(8,9): error TS7029: Fallthrough case in switch. +tests/cases/compiler/fallFromLastCase2.ts(21,9): error TS7029: Fallthrough case in switch. ==== tests/cases/compiler/fallFromLastCase2.ts (2 errors) ==== - declare function use(a: string); function foo1(a: number) { diff --git a/tests/baselines/reference/fallFromLastCase2.js b/tests/baselines/reference/fallFromLastCase2.js index fd1d7c20d07..44f9608d6ba 100644 --- a/tests/baselines/reference/fallFromLastCase2.js +++ b/tests/baselines/reference/fallFromLastCase2.js @@ -1,5 +1,4 @@ //// [fallFromLastCase2.ts] - declare function use(a: string); function foo1(a: number) { diff --git a/tests/baselines/reference/fatarrowfunctions.js b/tests/baselines/reference/fatarrowfunctions.js index eb57d1a9817..d3ec0c47054 100644 --- a/tests/baselines/reference/fatarrowfunctions.js +++ b/tests/baselines/reference/fatarrowfunctions.js @@ -1,5 +1,4 @@ //// [fatarrowfunctions.ts] - function foo(x:any) { return x(); } diff --git a/tests/baselines/reference/fatarrowfunctions.symbols b/tests/baselines/reference/fatarrowfunctions.symbols index 6ed865b0914..dae8380dc73 100644 --- a/tests/baselines/reference/fatarrowfunctions.symbols +++ b/tests/baselines/reference/fatarrowfunctions.symbols @@ -1,106 +1,105 @@ === tests/cases/compiler/fatarrowfunctions.ts === - function foo(x:any) { >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 1, 13)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 0, 13)) return x(); ->x : Symbol(x, Decl(fatarrowfunctions.ts, 1, 13)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 0, 13)) } foo((x:number,y,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 16)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 5, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 5, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 5, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 5, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 5, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 5, 16)) foo((x,y,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 9)) foo((x,y:number,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 16)) foo((x,y:number,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 16)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16)) foo((x,y,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 10, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 10, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 10, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 10, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 10, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 10, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 9)) foo(()=>{return 0;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) foo((x:number,y,z)=>x+y+z); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 16)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 12, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 12, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 12, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 12, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 12, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 12, 16)) foo((x,y,z)=>x+y+z); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 9)) foo((x,y:number,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 16)) foo((x,y:number,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 16)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16)) foo((x,y,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 17, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 17, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 17, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 17, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 17, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 17, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 9)) foo(()=>{return 0;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) @@ -108,61 +107,61 @@ foo(()=>{return 0;}); foo(((x) => x)); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 20, 6)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 20, 6)) foo(x => x*x); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 22, 4)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 22, 4)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 22, 4)) var y = x => x*x; ->y : Symbol(y, Decl(fatarrowfunctions.ts, 25, 3)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 24, 3)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 24, 7)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 24, 7)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 24, 7)) var z = (x:number) => x*x; ->z : Symbol(z, Decl(fatarrowfunctions.ts, 26, 3)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 25, 3)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 9)) var w = () => 3; ->w : Symbol(w, Decl(fatarrowfunctions.ts, 28, 3)) +>w : Symbol(w, Decl(fatarrowfunctions.ts, 27, 3)) function ternaryTest(isWhile:boolean) { ->ternaryTest : Symbol(ternaryTest, Decl(fatarrowfunctions.ts, 28, 16)) ->isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 30, 21)) +>ternaryTest : Symbol(ternaryTest, Decl(fatarrowfunctions.ts, 27, 16)) +>isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 29, 21)) var f = isWhile ? function (n) { return n > 0; } : function (n) { return n === 0; }; ->f : Symbol(f, Decl(fatarrowfunctions.ts, 32, 19)) ->isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 30, 21)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77)) +>f : Symbol(f, Decl(fatarrowfunctions.ts, 31, 19)) +>isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 29, 21)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 44)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 44)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 77)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 77)) } declare function setTimeout(expression: any, msec?: number, language?: any): number; ->setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1)) ->expression : Symbol(expression, Decl(fatarrowfunctions.ts, 36, 28)) ->msec : Symbol(msec, Decl(fatarrowfunctions.ts, 36, 44)) ->language : Symbol(language, Decl(fatarrowfunctions.ts, 36, 59)) +>setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 33, 1)) +>expression : Symbol(expression, Decl(fatarrowfunctions.ts, 35, 28)) +>msec : Symbol(msec, Decl(fatarrowfunctions.ts, 35, 44)) +>language : Symbol(language, Decl(fatarrowfunctions.ts, 35, 59)) var messenger = { ->messenger : Symbol(messenger, Decl(fatarrowfunctions.ts, 38, 3)) +>messenger : Symbol(messenger, Decl(fatarrowfunctions.ts, 37, 3)) message: "Hello World", ->message : Symbol(message, Decl(fatarrowfunctions.ts, 38, 17)) +>message : Symbol(message, Decl(fatarrowfunctions.ts, 37, 17)) start: function() { ->start : Symbol(start, Decl(fatarrowfunctions.ts, 39, 27)) +>start : Symbol(start, Decl(fatarrowfunctions.ts, 38, 27)) setTimeout(() => { this.message.toString(); }, 3000); ->setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1)) +>setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 33, 1)) } }; diff --git a/tests/baselines/reference/fatarrowfunctions.types b/tests/baselines/reference/fatarrowfunctions.types index 304c341c916..6ed37080a23 100644 --- a/tests/baselines/reference/fatarrowfunctions.types +++ b/tests/baselines/reference/fatarrowfunctions.types @@ -1,5 +1,4 @@ === tests/cases/compiler/fatarrowfunctions.ts === - function foo(x:any) { >foo : (x: any) => any >x : any diff --git a/tests/baselines/reference/flowInFinally1.js b/tests/baselines/reference/flowInFinally1.js index b6bf494e832..76769342c01 100644 --- a/tests/baselines/reference/flowInFinally1.js +++ b/tests/baselines/reference/flowInFinally1.js @@ -1,5 +1,4 @@ //// [flowInFinally1.ts] - class A { constructor() { } method() { } diff --git a/tests/baselines/reference/flowInFinally1.symbols b/tests/baselines/reference/flowInFinally1.symbols index 2ecedaee025..dd4a3a88c64 100644 --- a/tests/baselines/reference/flowInFinally1.symbols +++ b/tests/baselines/reference/flowInFinally1.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/flowInFinally1.ts === - class A { >A : Symbol(A, Decl(flowInFinally1.ts, 0, 0)) constructor() { } method() { } ->method : Symbol(A.method, Decl(flowInFinally1.ts, 2, 19)) +>method : Symbol(A.method, Decl(flowInFinally1.ts, 1, 19)) } let a: A | null = null; ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) >A : Symbol(A, Decl(flowInFinally1.ts, 0, 0)) try { a = new A(); ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) >A : Symbol(A, Decl(flowInFinally1.ts, 0, 0)) } finally { if (a) { ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) a.method(); ->a.method : Symbol(A.method, Decl(flowInFinally1.ts, 2, 19)) ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) ->method : Symbol(A.method, Decl(flowInFinally1.ts, 2, 19)) +>a.method : Symbol(A.method, Decl(flowInFinally1.ts, 1, 19)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) +>method : Symbol(A.method, Decl(flowInFinally1.ts, 1, 19)) } } diff --git a/tests/baselines/reference/flowInFinally1.types b/tests/baselines/reference/flowInFinally1.types index c9cbab6dbd1..c0fba9bf593 100644 --- a/tests/baselines/reference/flowInFinally1.types +++ b/tests/baselines/reference/flowInFinally1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/flowInFinally1.ts === - class A { >A : A diff --git a/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt b/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt index 03361cfcfab..a47ea077d95 100644 --- a/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt +++ b/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(5,16): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(6,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(7,9): error TS2365: Operator '===' cannot be applied to types 'string' and 'number'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(9,16): error TS2339: Property 'unknownProperty' does not exist on type 'string'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(13,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'number', but here has type 'string'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(17,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'j' must be of type 'any', but here has type 'string'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(4,16): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(5,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(6,9): error TS2365: Operator '===' cannot be applied to types 'string' and 'number'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(8,16): error TS2339: Property 'unknownProperty' does not exist on type 'string'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(12,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'number', but here has type 'string'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(16,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'j' must be of type 'any', but here has type 'string'. ==== tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts (6 errors) ==== - let a: Date[]; for (let x in a) { diff --git a/tests/baselines/reference/for-inStatementsArrayErrors.js b/tests/baselines/reference/for-inStatementsArrayErrors.js index 981a840695c..c80f5e45396 100644 --- a/tests/baselines/reference/for-inStatementsArrayErrors.js +++ b/tests/baselines/reference/for-inStatementsArrayErrors.js @@ -1,5 +1,4 @@ //// [for-inStatementsArrayErrors.ts] - let a: Date[]; for (let x in a) { diff --git a/tests/baselines/reference/for.errors.txt b/tests/baselines/reference/for.errors.txt index d2caefbcdae..41ed5765c9a 100644 --- a/tests/baselines/reference/for.errors.txt +++ b/tests/baselines/reference/for.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/for.ts(30,6): error TS1109: Expression expected. +tests/cases/compiler/for.ts(29,6): error TS1109: Expression expected. ==== tests/cases/compiler/for.ts (1 errors) ==== - for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/baselines/reference/for.js b/tests/baselines/reference/for.js index 857d42bafdb..a77b68d8b6e 100644 --- a/tests/baselines/reference/for.js +++ b/tests/baselines/reference/for.js @@ -1,5 +1,4 @@ //// [for.ts] - for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/baselines/reference/forBreakStatements.js b/tests/baselines/reference/forBreakStatements.js index da4fccdfd2a..9ed65627c9c 100644 --- a/tests/baselines/reference/forBreakStatements.js +++ b/tests/baselines/reference/forBreakStatements.js @@ -1,5 +1,4 @@ //// [forBreakStatements.ts] - for (; ;) { break; } diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols index 6d869b45934..76db9309a39 100644 --- a/tests/baselines/reference/forBreakStatements.symbols +++ b/tests/baselines/reference/forBreakStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts === - for (; ;) { break; } @@ -34,7 +33,7 @@ for (; ;) for (; ;) for (; ;) break SEVEN; EIGHT: for (; ;) { var fn = function () { } ->fn : Symbol(fn, Decl(forBreakStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forBreakStatements.ts, 33, 7)) break EIGHT; } diff --git a/tests/baselines/reference/forBreakStatements.types b/tests/baselines/reference/forBreakStatements.types index c494f6be30a..8469a85bd19 100644 --- a/tests/baselines/reference/forBreakStatements.types +++ b/tests/baselines/reference/forBreakStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts === - for (; ;) { break; } diff --git a/tests/baselines/reference/forContinueStatements.js b/tests/baselines/reference/forContinueStatements.js index fc5aa0434b3..34f70bb1fc1 100644 --- a/tests/baselines/reference/forContinueStatements.js +++ b/tests/baselines/reference/forContinueStatements.js @@ -1,5 +1,4 @@ //// [forContinueStatements.ts] - for (; ;) { continue; } diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols index 9e0c396acfb..e24eb2aaa92 100644 --- a/tests/baselines/reference/forContinueStatements.symbols +++ b/tests/baselines/reference/forContinueStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts === - for (; ;) { continue; } @@ -34,7 +33,7 @@ for (; ;) for (; ;) for (; ;) continue SEVEN; EIGHT: for (; ;) { var fn = function () { } ->fn : Symbol(fn, Decl(forContinueStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forContinueStatements.ts, 33, 7)) continue EIGHT; } diff --git a/tests/baselines/reference/forContinueStatements.types b/tests/baselines/reference/forContinueStatements.types index 0b52bdd5d47..79b78e83345 100644 --- a/tests/baselines/reference/forContinueStatements.types +++ b/tests/baselines/reference/forContinueStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts === - for (; ;) { continue; } diff --git a/tests/baselines/reference/forInBreakStatements.js b/tests/baselines/reference/forInBreakStatements.js index ebbadb31277..24b7cc57b8d 100644 --- a/tests/baselines/reference/forInBreakStatements.js +++ b/tests/baselines/reference/forInBreakStatements.js @@ -1,5 +1,4 @@ //// [forInBreakStatements.ts] - for(var x in {}) { break; } diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols index 5f48e110835..7984edc3fd6 100644 --- a/tests/baselines/reference/forInBreakStatements.symbols +++ b/tests/baselines/reference/forInBreakStatements.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts === - for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break; } ONE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break ONE; } @@ -16,43 +15,43 @@ for(var x in {}) { TWO: THREE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break THREE; } FOUR: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) FIVE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break FOUR; } } for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) SIX: for(var x in {}) break SIX; ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) } SEVEN: for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN; ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) EIGHT: for (var x in {}){ ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) var fn = function () { } ->fn : Symbol(fn, Decl(forInBreakStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forInBreakStatements.ts, 33, 7)) break EIGHT; } diff --git a/tests/baselines/reference/forInBreakStatements.types b/tests/baselines/reference/forInBreakStatements.types index 4f4b9b3bef9..bdbec8e9bfe 100644 --- a/tests/baselines/reference/forInBreakStatements.types +++ b/tests/baselines/reference/forInBreakStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts === - for(var x in {}) { >x : string >{} : {} diff --git a/tests/baselines/reference/forInContinueStatements.js b/tests/baselines/reference/forInContinueStatements.js index ca530dd5d6c..8b036c59721 100644 --- a/tests/baselines/reference/forInContinueStatements.js +++ b/tests/baselines/reference/forInContinueStatements.js @@ -1,5 +1,4 @@ //// [forInContinueStatements.ts] - for(var x in {}) { continue; } diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols index a0edea53f3e..88129a50d21 100644 --- a/tests/baselines/reference/forInContinueStatements.symbols +++ b/tests/baselines/reference/forInContinueStatements.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts === - for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue; } ONE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue ONE; } @@ -16,43 +15,43 @@ for(var x in {}) { TWO: THREE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue THREE; } FOUR: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) FIVE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue FOUR; } } for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) SIX: for(var x in {}) continue SIX; ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) } SEVEN: for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN; ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) EIGHT: for (var x in {}){ ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) var fn = function () { } ->fn : Symbol(fn, Decl(forInContinueStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forInContinueStatements.ts, 33, 7)) continue EIGHT; } diff --git a/tests/baselines/reference/forInContinueStatements.types b/tests/baselines/reference/forInContinueStatements.types index e45cc798542..b53d584e137 100644 --- a/tests/baselines/reference/forInContinueStatements.types +++ b/tests/baselines/reference/forInContinueStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts === - for(var x in {}) { >x : string >{} : {} diff --git a/tests/baselines/reference/forStatements.js b/tests/baselines/reference/forStatements.js index c380185ecf5..f10a105ecd5 100644 --- a/tests/baselines/reference/forStatements.js +++ b/tests/baselines/reference/forStatements.js @@ -1,5 +1,4 @@ //// [forStatements.ts] - interface I { id: number; } diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols index 84cd7dc70d1..e775d615f36 100644 --- a/tests/baselines/reference/forStatements.symbols +++ b/tests/baselines/reference/forStatements.symbols @@ -1,146 +1,145 @@ === tests/cases/conformance/statements/forStatements/forStatements.ts === - interface I { >I : Symbol(I, Decl(forStatements.ts, 0, 0)) id: number; ->id : Symbol(I.id, Decl(forStatements.ts, 1, 13)) +>id : Symbol(I.id, Decl(forStatements.ts, 0, 13)) } class C implements I { ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) id: number; ->id : Symbol(C.id, Decl(forStatements.ts, 5, 22)) +>id : Symbol(C.id, Decl(forStatements.ts, 4, 22)) } class D{ ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) source: T; ->source : Symbol(D.source, Decl(forStatements.ts, 9, 11)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>source : Symbol(D.source, Decl(forStatements.ts, 8, 11)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) recurse: D; ->recurse : Symbol(D.recurse, Decl(forStatements.ts, 10, 14)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>recurse : Symbol(D.recurse, Decl(forStatements.ts, 9, 14)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) wrapped: D> ->wrapped : Symbol(D.wrapped, Decl(forStatements.ts, 11, 18)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>wrapped : Symbol(D.wrapped, Decl(forStatements.ts, 10, 18)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) ->x : Symbol(x, Decl(forStatements.ts, 15, 11)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>x : Symbol(x, Decl(forStatements.ts, 14, 11)) module M { ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) export class A { ->A : Symbol(A, Decl(forStatements.ts, 17, 10)) +>A : Symbol(A, Decl(forStatements.ts, 16, 10)) name: string; ->name : Symbol(A.name, Decl(forStatements.ts, 18, 20)) +>name : Symbol(A.name, Decl(forStatements.ts, 17, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(forStatements.ts, 20, 5)) ->x : Symbol(x, Decl(forStatements.ts, 22, 23)) +>F2 : Symbol(F2, Decl(forStatements.ts, 19, 5)) +>x : Symbol(x, Decl(forStatements.ts, 21, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(forStatements.ts, 22, 23)) +>x : Symbol(x, Decl(forStatements.ts, 21, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } for(var aNumber: number = 9.9;;){} ->aNumber : Symbol(aNumber, Decl(forStatements.ts, 25, 7)) +>aNumber : Symbol(aNumber, Decl(forStatements.ts, 24, 7)) for(var aString: string = 'this is a string';;){} ->aString : Symbol(aString, Decl(forStatements.ts, 26, 7)) +>aString : Symbol(aString, Decl(forStatements.ts, 25, 7)) for(var aDate: Date = new Date(12);;){} ->aDate : Symbol(aDate, Decl(forStatements.ts, 27, 7)) +>aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for(var anObject: Object = new Object();;){} ->anObject : Symbol(anObject, Decl(forStatements.ts, 28, 7)) +>anObject : Symbol(anObject, Decl(forStatements.ts, 27, 7)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for(var anAny: any = null;;){} ->anAny : Symbol(anAny, Decl(forStatements.ts, 30, 7)) +>anAny : Symbol(anAny, Decl(forStatements.ts, 29, 7)) for(var aSecondAny: any = undefined;;){} ->aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 31, 7)) +>aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 30, 7)) >undefined : Symbol(undefined) for(var aVoid: void = undefined;;){} ->aVoid : Symbol(aVoid, Decl(forStatements.ts, 32, 7)) +>aVoid : Symbol(aVoid, Decl(forStatements.ts, 31, 7)) >undefined : Symbol(undefined) for(var anInterface: I = new C();;){} ->anInterface : Symbol(anInterface, Decl(forStatements.ts, 34, 7)) +>anInterface : Symbol(anInterface, Decl(forStatements.ts, 33, 7)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) for(var aClass: C = new C();;){} ->aClass : Symbol(aClass, Decl(forStatements.ts, 35, 7)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>aClass : Symbol(aClass, Decl(forStatements.ts, 34, 7)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) for(var aGenericClass: D = new D();;){} ->aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 36, 7)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 35, 7)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) for(var anObjectLiteral: I = { id: 12 };;){} ->anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 37, 7)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 36, 7)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) ->id : Symbol(id, Decl(forStatements.ts, 37, 30)) +>id : Symbol(id, Decl(forStatements.ts, 36, 30)) for(var anOtherObjectLiteral: { id: number } = new C();;){} ->anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 38, 7)) ->id : Symbol(id, Decl(forStatements.ts, 38, 31)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 37, 7)) +>id : Symbol(id, Decl(forStatements.ts, 37, 31)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) for(var aFunction: typeof F = F;;){} ->aFunction : Symbol(aFunction, Decl(forStatements.ts, 40, 7)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>aFunction : Symbol(aFunction, Decl(forStatements.ts, 39, 7)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) for(var anOtherFunction: (x: string) => number = F;;){} ->anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 41, 7)) ->x : Symbol(x, Decl(forStatements.ts, 41, 26)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 40, 7)) +>x : Symbol(x, Decl(forStatements.ts, 40, 26)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) for(var aLambda: typeof F = (x) => 2;;){} ->aLambda : Symbol(aLambda, Decl(forStatements.ts, 42, 7)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) ->x : Symbol(x, Decl(forStatements.ts, 42, 29)) +>aLambda : Symbol(aLambda, Decl(forStatements.ts, 41, 7)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>x : Symbol(x, Decl(forStatements.ts, 41, 29)) for(var aModule: typeof M = M;;){} ->aModule : Symbol(aModule, Decl(forStatements.ts, 44, 7)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>aModule : Symbol(aModule, Decl(forStatements.ts, 43, 7)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) for(var aClassInModule: M.A = new M.A();;){} ->aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 45, 7)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) ->M.A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) +>aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 44, 7)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) +>M.A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){} ->aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 46, 7)) ->M.F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5)) ->x : Symbol(x, Decl(forStatements.ts, 46, 42)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 45, 7)) +>M.F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5)) +>x : Symbol(x, Decl(forStatements.ts, 45, 42)) diff --git a/tests/baselines/reference/forStatements.types b/tests/baselines/reference/forStatements.types index a6ae6ea9aa5..7c467d31847 100644 --- a/tests/baselines/reference/forStatements.types +++ b/tests/baselines/reference/forStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/forStatements/forStatements.ts === - interface I { >I : I diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt index f1869ae7fca..53ecb88363d 100644 --- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt +++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt @@ -1,19 +1,18 @@ -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'string'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'C'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'D'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(37,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'typeof M'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(41,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C2'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(44,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type 'number[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(48,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type '(C | D)[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(51,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr2' must be of type 'D[]', but here has type 'D[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(54,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'm' must be of type 'typeof M', but here has type 'typeof A'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(32,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'string'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'C'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'D'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'typeof M'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(39,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C2'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type 'number[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type '(C | D)[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr2' must be of type 'D[]', but here has type 'D[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'm' must be of type 'typeof M', but here has type 'typeof A'. ==== tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts (12 errors) ==== - interface I { id: number; } diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js index 27284f8b272..e6404a73c60 100644 --- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js +++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js @@ -1,5 +1,4 @@ //// [forStatementsMultipleInvalidDecl.ts] - interface I { id: number; } diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.js b/tests/baselines/reference/forStatementsMultipleValidDecl.js index 6913894a15f..e95e37d63ac 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.js +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.js @@ -1,5 +1,4 @@ //// [forStatementsMultipleValidDecl.ts] - // all expected to be valid for (var x: number; ;) { } diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols index 89e36c4a8f5..efb1e576975 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols @@ -1,111 +1,110 @@ === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts === - // all expected to be valid for (var x: number; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) for (var x = 2; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) for (var x = undefined; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) >undefined : Symbol(undefined) // new declaration space, making redeclaring x as a string valid function declSpace() { ->declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 6, 38)) +>declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 5, 38)) for (var x = 'this is a string'; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 9, 12)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 8, 12)) } interface Point { x: number; y: number; } ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) ->x : Symbol(Point.x, Decl(forStatementsMultipleValidDecl.ts, 11, 17)) ->y : Symbol(Point.y, Decl(forStatementsMultipleValidDecl.ts, 11, 28)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) +>x : Symbol(Point.x, Decl(forStatementsMultipleValidDecl.ts, 10, 17)) +>y : Symbol(Point.y, Decl(forStatementsMultipleValidDecl.ts, 10, 28)) for (var p: Point; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) for (var p = { x: 1, y: 2 }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 14)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 20)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 13, 14)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 13, 20)) for (var p: Point = { x: 0, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 21)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 27)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 21)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 27)) >undefined : Symbol(undefined) for (var p = { x: 1, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 14)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 20)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 14)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 20)) >undefined : Symbol(undefined) for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 13)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 24)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 13)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 24)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 41)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 47)) for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 15)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 26)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 41)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 47)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 15)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 26)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47)) >undefined : Symbol(undefined) for (var p: typeof p; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) for (var fn = function (s: string) { return 42; }; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 24)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 20, 24)) for (var fn = (s: string) => 3; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 15)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 15)) for (var fn: (s: string) => number; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 14)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 14)) for (var fn: { (s: string): number }; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 16)) for (var fn = <(s: string) => number> null; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 25, 16)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16)) for (var fn: typeof fn; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) for (var a: string[]; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a = ['a', 'b']; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a = []; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a: string[] = []; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a = new Array(); ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var a: typeof a; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.types b/tests/baselines/reference/forStatementsMultipleValidDecl.types index f40f4bbbc3c..d0950d67924 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.types +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts === - // all expected to be valid for (var x: number; ;) { } diff --git a/tests/baselines/reference/functionCalls.errors.txt b/tests/baselines/reference/functionCalls.errors.txt index dc1417cdc98..85e75876779 100644 --- a/tests/baselines/reference/functionCalls.errors.txt +++ b/tests/baselines/reference/functionCalls.errors.txt @@ -1,16 +1,15 @@ +tests/cases/conformance/expressions/functionCalls/functionCalls.ts(8,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(9,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(10,1): error TS2347: Untyped function calls may not accept type arguments. -tests/cases/conformance/expressions/functionCalls/functionCalls.ts(11,1): error TS2347: Untyped function calls may not accept type arguments. +tests/cases/conformance/expressions/functionCalls/functionCalls.ts(25,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(26,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(27,1): error TS2347: Untyped function calls may not accept type arguments. -tests/cases/conformance/expressions/functionCalls/functionCalls.ts(28,1): error TS2347: Untyped function calls may not accept type arguments. +tests/cases/conformance/expressions/functionCalls/functionCalls.ts(32,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(33,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(34,1): error TS2347: Untyped function calls may not accept type arguments. -tests/cases/conformance/expressions/functionCalls/functionCalls.ts(35,1): error TS2347: Untyped function calls may not accept type arguments. ==== tests/cases/conformance/expressions/functionCalls/functionCalls.ts (9 errors) ==== - // Invoke function call on value of type 'any' with no type arguments var anyVar: any; anyVar(0); diff --git a/tests/baselines/reference/functionCalls.js b/tests/baselines/reference/functionCalls.js index e7b80fffdd8..bba73092b46 100644 --- a/tests/baselines/reference/functionCalls.js +++ b/tests/baselines/reference/functionCalls.js @@ -1,5 +1,4 @@ //// [functionCalls.ts] - // Invoke function call on value of type 'any' with no type arguments var anyVar: any; anyVar(0); diff --git a/tests/baselines/reference/functionImplementationErrors.errors.txt b/tests/baselines/reference/functionImplementationErrors.errors.txt index 224ebc7c08e..5ed54e044d2 100644 --- a/tests/baselines/reference/functionImplementationErrors.errors.txt +++ b/tests/baselines/reference/functionImplementationErrors.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/functions/functionImplementationErrors.ts(26,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/conformance/functions/functionImplementationErrors.ts(31,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. -tests/cases/conformance/functions/functionImplementationErrors.ts(36,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. +tests/cases/conformance/functions/functionImplementationErrors.ts(25,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/conformance/functions/functionImplementationErrors.ts(30,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. +tests/cases/conformance/functions/functionImplementationErrors.ts(35,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. ==== tests/cases/conformance/functions/functionImplementationErrors.ts (3 errors) ==== - // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; diff --git a/tests/baselines/reference/functionImplementationErrors.js b/tests/baselines/reference/functionImplementationErrors.js index e227693b386..533aa9e9d27 100644 --- a/tests/baselines/reference/functionImplementationErrors.js +++ b/tests/baselines/reference/functionImplementationErrors.js @@ -1,5 +1,4 @@ //// [functionImplementationErrors.ts] - // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; diff --git a/tests/baselines/reference/functionImplementations.js b/tests/baselines/reference/functionImplementations.js index 994ff36da56..bc1a83aa16a 100644 --- a/tests/baselines/reference/functionImplementations.js +++ b/tests/baselines/reference/functionImplementations.js @@ -1,5 +1,4 @@ //// [functionImplementations.ts] - // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols index 1d8c5b2618b..4f2f814ccef 100644 --- a/tests/baselines/reference/functionImplementations.symbols +++ b/tests/baselines/reference/functionImplementations.symbols @@ -1,110 +1,109 @@ === tests/cases/conformance/functions/functionImplementations.ts === - // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); ->v : Symbol(v, Decl(functionImplementations.ts, 2, 3)) +>v : Symbol(v, Decl(functionImplementations.ts, 1, 3)) // FunctionExpression f with no return type annotation and directly references f in its body returns any var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 5, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 4, 12)) return f; ->f : Symbol(f, Decl(functionImplementations.ts, 5, 12)) +>f : Symbol(f, Decl(functionImplementations.ts, 4, 12)) }; var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 8, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 7, 12)) return f(); ->f : Symbol(f, Decl(functionImplementations.ts, 8, 12)) +>f : Symbol(f, Decl(functionImplementations.ts, 7, 12)) }; // FunctionExpression f with no return type annotation and indirectly references f in its body returns any var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 13, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 12, 12)) var x = f; ->x : Symbol(x, Decl(functionImplementations.ts, 14, 7)) ->f : Symbol(f, Decl(functionImplementations.ts, 13, 12)) +>x : Symbol(x, Decl(functionImplementations.ts, 13, 7)) +>f : Symbol(f, Decl(functionImplementations.ts, 12, 12)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 14, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 13, 7)) }; // Two mutually recursive function implementations with no return type annotations function rec1() { ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) return rec2(); ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) } function rec2() { ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) return rec1(); ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) } var a = rec1(); ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) var a = rec2(); ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) // Two mutually recursive function implementations with return type annotation in one function rec3(): number { ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) return rec4(); ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) } function rec4() { ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) return rec3(); ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) } var n: number; ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) var n = rec3(); ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) var n = rec4(); ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) // FunctionExpression with no return type annotation and returns a number var n = function () { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) return 3; } (); // FunctionExpression with no return type annotation and returns null var nu = null; ->nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3)) +>nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3)) var nu = function () { ->nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3)) +>nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3)) return null; } (); // FunctionExpression with no return type annotation and returns undefined var un = undefined; ->un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3)) +>un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3)) >undefined : Symbol(undefined) var un = function () { ->un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3)) +>un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3)) return undefined; >undefined : Symbol(undefined) @@ -113,31 +112,31 @@ var un = function () { // FunctionExpression with no return type annotation and returns a type parameter type var n = function (x: T) { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->T : Symbol(T, Decl(functionImplementations.ts, 57, 18)) ->x : Symbol(x, Decl(functionImplementations.ts, 57, 21)) ->T : Symbol(T, Decl(functionImplementations.ts, 57, 18)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>T : Symbol(T, Decl(functionImplementations.ts, 56, 18)) +>x : Symbol(x, Decl(functionImplementations.ts, 56, 21)) +>T : Symbol(T, Decl(functionImplementations.ts, 56, 18)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 57, 21)) +>x : Symbol(x, Decl(functionImplementations.ts, 56, 21)) } (4); // FunctionExpression with no return type annotation and returns a constrained type parameter type var n = function (x: T) { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->T : Symbol(T, Decl(functionImplementations.ts, 62, 18)) ->x : Symbol(x, Decl(functionImplementations.ts, 62, 32)) ->T : Symbol(T, Decl(functionImplementations.ts, 62, 18)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>T : Symbol(T, Decl(functionImplementations.ts, 61, 18)) +>x : Symbol(x, Decl(functionImplementations.ts, 61, 32)) +>T : Symbol(T, Decl(functionImplementations.ts, 61, 18)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 62, 32)) +>x : Symbol(x, Decl(functionImplementations.ts, 61, 32)) } (4); // FunctionExpression with no return type annotation with multiple return statements with identical types var n = function () { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) return 3; return 5; @@ -149,36 +148,36 @@ var n = function () { // A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others. // FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns class Base { private m; } ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->m : Symbol(Base.m, Decl(functionImplementations.ts, 77, 12)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>m : Symbol(Base.m, Decl(functionImplementations.ts, 76, 12)) class Derived extends Base { private q; } ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->q : Symbol(Derived.q, Decl(functionImplementations.ts, 78, 28)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>q : Symbol(Derived.q, Decl(functionImplementations.ts, 77, 28)) var b: Base; ->b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) var b = function () { ->b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3)) +>b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3)) return new Base(); return new Derived(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) } (); // FunctionExpression with no return type annotation with multiple return statements with one a recursive call var a = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 85, 7)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 84, 7)) return new Base(); return new Derived(); return f(); // ? ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) ->f : Symbol(f, Decl(functionImplementations.ts, 85, 7)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>f : Symbol(f, Decl(functionImplementations.ts, 84, 7)) } (); @@ -193,59 +192,59 @@ undefined === function (): number { // Type of 'this' in function implementation is 'any' function thisFunc() { ->thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 92, 2)) +>thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 91, 2)) var x = this; ->x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7)) var x: any; ->x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7)) } // Function signature with optional parameter, no type annotation and initializer has initializer's type function opt1(n = 4) { ->opt1 : Symbol(opt1, Decl(functionImplementations.ts, 98, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 101, 14)) +>opt1 : Symbol(opt1, Decl(functionImplementations.ts, 97, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 100, 14)) var m = n; ->m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7)) ->n : Symbol(n, Decl(functionImplementations.ts, 101, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7)) +>n : Symbol(n, Decl(functionImplementations.ts, 100, 14)) var m: number; ->m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7)) +>m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7)) } // Function signature with optional parameter, no type annotation and initializer has initializer's widened type function opt2(n = { x: null, y: undefined }) { ->opt2 : Symbol(opt2, Decl(functionImplementations.ts, 104, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 107, 14)) ->x : Symbol(x, Decl(functionImplementations.ts, 107, 19)) ->y : Symbol(y, Decl(functionImplementations.ts, 107, 28)) +>opt2 : Symbol(opt2, Decl(functionImplementations.ts, 103, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 106, 14)) +>x : Symbol(x, Decl(functionImplementations.ts, 106, 19)) +>y : Symbol(y, Decl(functionImplementations.ts, 106, 28)) >undefined : Symbol(undefined) var m = n; ->m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7)) ->n : Symbol(n, Decl(functionImplementations.ts, 107, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7)) +>n : Symbol(n, Decl(functionImplementations.ts, 106, 14)) var m: { x: any; y: any }; ->m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7)) ->x : Symbol(x, Decl(functionImplementations.ts, 109, 12)) ->y : Symbol(y, Decl(functionImplementations.ts, 109, 20)) +>m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 108, 12)) +>y : Symbol(y, Decl(functionImplementations.ts, 108, 20)) } // Function signature with initializer referencing other parameter to the left function opt3(n: number, m = n) { ->opt3 : Symbol(opt3, Decl(functionImplementations.ts, 110, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 113, 14)) ->m : Symbol(m, Decl(functionImplementations.ts, 113, 24)) ->n : Symbol(n, Decl(functionImplementations.ts, 113, 14)) +>opt3 : Symbol(opt3, Decl(functionImplementations.ts, 109, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 112, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 112, 24)) +>n : Symbol(n, Decl(functionImplementations.ts, 112, 14)) var y = m; ->y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7)) ->m : Symbol(m, Decl(functionImplementations.ts, 113, 24)) +>y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7)) +>m : Symbol(m, Decl(functionImplementations.ts, 112, 24)) var y: number; ->y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7)) +>y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7)) } // Function signature with optional parameter has correct codegen @@ -253,93 +252,93 @@ function opt3(n: number, m = n) { // FunctionExpression with non -void return type annotation return with no expression function f6(): number { ->f6 : Symbol(f6, Decl(functionImplementations.ts, 116, 1)) +>f6 : Symbol(f6, Decl(functionImplementations.ts, 115, 1)) return; } class Derived2 extends Base { private r: string; } ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->r : Symbol(Derived2.r, Decl(functionImplementations.ts, 126, 29)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>r : Symbol(Derived2.r, Decl(functionImplementations.ts, 125, 29)) class AnotherClass { private x } ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) ->x : Symbol(AnotherClass.x, Decl(functionImplementations.ts, 127, 20)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) +>x : Symbol(AnotherClass.x, Decl(functionImplementations.ts, 126, 20)) // if f is a contextually typed function expression, the inferred return type is the union type // of the types of the return statement expressions in the function body, // ignoring return statements with no expressions. var f7: (x: number) => string | number = x => { // should be (x: number) => number | string ->f7 : Symbol(f7, Decl(functionImplementations.ts, 131, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>f7 : Symbol(f7, Decl(functionImplementations.ts, 130, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) if (x < 0) { return x; } ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) return x.toString(); >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var f8: (x: number) => any = x => { // should be (x: number) => Base ->f8 : Symbol(f8, Decl(functionImplementations.ts, 135, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 135, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 135, 28)) +>f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 134, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 134, 28)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) } var f9: (x: number) => any = x => { // should be (x: number) => Base ->f9 : Symbol(f9, Decl(functionImplementations.ts, 139, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 139, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 139, 28)) +>f9 : Symbol(f9, Decl(functionImplementations.ts, 138, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 138, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 138, 28)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return new Derived(); ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) } var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1 ->f10 : Symbol(f10, Decl(functionImplementations.ts, 144, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 144, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 144, 29)) +>f10 : Symbol(f10, Decl(functionImplementations.ts, 143, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 143, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 143, 29)) return new Derived(); ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) } var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass ->f11 : Symbol(f11, Decl(functionImplementations.ts, 148, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 148, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 148, 29)) +>f11 : Symbol(f11, Decl(functionImplementations.ts, 147, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 147, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 147, 29)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return new AnotherClass(); ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) } var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass ->f12 : Symbol(f12, Decl(functionImplementations.ts, 152, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 152, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 152, 29)) +>f12 : Symbol(f12, Decl(functionImplementations.ts, 151, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 151, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 151, 29)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return; // should be ignored return new AnotherClass(); ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) } diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types index d81b02598bd..43ed3fe24fe 100644 --- a/tests/baselines/reference/functionImplementations.types +++ b/tests/baselines/reference/functionImplementations.types @@ -1,5 +1,4 @@ === tests/cases/conformance/functions/functionImplementations.ts === - // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); >v : void diff --git a/tests/baselines/reference/functionOverloads12.js b/tests/baselines/reference/functionOverloads12.js index 8d834e8180f..4681e43ee5b 100644 --- a/tests/baselines/reference/functionOverloads12.js +++ b/tests/baselines/reference/functionOverloads12.js @@ -1,5 +1,4 @@ //// [functionOverloads12.ts] - function foo():string; function foo():number; function foo():any { if (true) return ""; else return 0;} diff --git a/tests/baselines/reference/functionOverloads12.symbols b/tests/baselines/reference/functionOverloads12.symbols index 4744f98c9f2..583e7f5c045 100644 --- a/tests/baselines/reference/functionOverloads12.symbols +++ b/tests/baselines/reference/functionOverloads12.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/functionOverloads12.ts === - function foo():string; ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) function foo():number; ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) function foo():any { if (true) return ""; else return 0;} ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) diff --git a/tests/baselines/reference/functionOverloads12.types b/tests/baselines/reference/functionOverloads12.types index d29f6262844..48f39b786f5 100644 --- a/tests/baselines/reference/functionOverloads12.types +++ b/tests/baselines/reference/functionOverloads12.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionOverloads12.ts === - function foo():string; >foo : { (): string; (): number; } diff --git a/tests/baselines/reference/functionReturn.js b/tests/baselines/reference/functionReturn.js index 42d0de5fd7c..c433eec190d 100644 --- a/tests/baselines/reference/functionReturn.js +++ b/tests/baselines/reference/functionReturn.js @@ -1,5 +1,4 @@ //// [functionReturn.ts] - function f0(): void { } function f1() { var n: any = f0(); diff --git a/tests/baselines/reference/functionReturn.symbols b/tests/baselines/reference/functionReturn.symbols index 630e435635b..9c6b794b3d0 100644 --- a/tests/baselines/reference/functionReturn.symbols +++ b/tests/baselines/reference/functionReturn.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/functionReturn.ts === - function f0(): void { } >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(functionReturn.ts, 1, 23)) +>f1 : Symbol(f1, Decl(functionReturn.ts, 0, 23)) var n: any = f0(); ->n : Symbol(n, Decl(functionReturn.ts, 3, 7)) +>n : Symbol(n, Decl(functionReturn.ts, 2, 7)) >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0)) } function f2(): any { } ->f2 : Symbol(f2, Decl(functionReturn.ts, 4, 1)) +>f2 : Symbol(f2, Decl(functionReturn.ts, 3, 1)) function f3(): string { return; } ->f3 : Symbol(f3, Decl(functionReturn.ts, 5, 22)) +>f3 : Symbol(f3, Decl(functionReturn.ts, 4, 22)) function f4(): string { ->f4 : Symbol(f4, Decl(functionReturn.ts, 6, 33)) +>f4 : Symbol(f4, Decl(functionReturn.ts, 5, 33)) return ''; return; } function f5(): string { ->f5 : Symbol(f5, Decl(functionReturn.ts, 10, 1)) +>f5 : Symbol(f5, Decl(functionReturn.ts, 9, 1)) return ''; return undefined; diff --git a/tests/baselines/reference/functionReturn.types b/tests/baselines/reference/functionReturn.types index 7b8f58de2a8..56cdc534c93 100644 --- a/tests/baselines/reference/functionReturn.types +++ b/tests/baselines/reference/functionReturn.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionReturn.ts === - function f0(): void { } >f0 : () => void diff --git a/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt b/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt index 84ec6ff1ba5..e99fb3bcf0d 100644 --- a/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt +++ b/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/functionTypesLackingReturnTypes.ts(3,17): error TS1005: '=>' expected. -tests/cases/compiler/functionTypesLackingReturnTypes.ts(7,9): error TS2304: Cannot find name 'param'. +tests/cases/compiler/functionTypesLackingReturnTypes.ts(2,17): error TS1005: '=>' expected. +tests/cases/compiler/functionTypesLackingReturnTypes.ts(6,9): error TS2304: Cannot find name 'param'. ==== tests/cases/compiler/functionTypesLackingReturnTypes.ts (2 errors) ==== - // Error (no '=>') function f(x: ()) { ~ diff --git a/tests/baselines/reference/functionTypesLackingReturnTypes.js b/tests/baselines/reference/functionTypesLackingReturnTypes.js index 10b447a838f..d12f5ebfe17 100644 --- a/tests/baselines/reference/functionTypesLackingReturnTypes.js +++ b/tests/baselines/reference/functionTypesLackingReturnTypes.js @@ -1,5 +1,4 @@ //// [functionTypesLackingReturnTypes.ts] - // Error (no '=>') function f(x: ()) { } diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.js b/tests/baselines/reference/functionWithMultipleReturnStatements.js index d44c37ebbf0..347a05d0f33 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.js +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.js @@ -1,5 +1,4 @@ //// [functionWithMultipleReturnStatements.ts] - // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.symbols b/tests/baselines/reference/functionWithMultipleReturnStatements.symbols index a33db459640..c1f9d9157bf 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.symbols +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts === - // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases @@ -14,7 +13,7 @@ function f1() { } function f2() { ->f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements.ts, 10, 1)) +>f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements.ts, 9, 1)) if (true) { return 1; @@ -26,26 +25,26 @@ function f2() { } function f3() { ->f3 : Symbol(f3, Decl(functionWithMultipleReturnStatements.ts, 20, 1)) +>f3 : Symbol(f3, Decl(functionWithMultipleReturnStatements.ts, 19, 1)) try { return 1; } catch (e) { ->e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 26, 11)) +>e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 25, 11)) return ''; } } function f4() { ->f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements.ts, 29, 1)) +>f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements.ts, 28, 1)) try { return 1; } catch (e) { ->e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 35, 11)) +>e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 34, 11)) } finally { @@ -54,50 +53,50 @@ function f4() { } function f5() { ->f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements.ts, 41, 1)) +>f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements.ts, 40, 1)) return 1; return ''; } function f6(x: T, y:U) { ->f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements.ts, 46, 1)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 48, 12)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 48, 14)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 48, 18)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 48, 12)) ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 48, 23)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 48, 14)) +>f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements.ts, 45, 1)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 47, 12)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 47, 14)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 47, 18)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 47, 12)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 47, 23)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 47, 14)) if (true) { return x; ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 48, 18)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 47, 18)) } else { return y; ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 48, 23)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 47, 23)) } } function f8(x: T, y: U) { ->f8 : Symbol(f8, Decl(functionWithMultipleReturnStatements.ts, 54, 1)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 56, 12)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 56, 24)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 56, 24)) ->V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 56, 37)) ->V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 56, 37)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 56, 41)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 56, 12)) ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 56, 46)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 56, 24)) +>f8 : Symbol(f8, Decl(functionWithMultipleReturnStatements.ts, 53, 1)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 55, 12)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 55, 24)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 55, 24)) +>V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 55, 37)) +>V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 55, 37)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 55, 41)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 55, 12)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 55, 46)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 55, 24)) if (true) { return x; ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 56, 41)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 55, 41)) } else { return y; ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 56, 46)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 55, 46)) } } diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.types b/tests/baselines/reference/functionWithMultipleReturnStatements.types index fec29e5a01b..8d2a4985d98 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.types +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts === - // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.js b/tests/baselines/reference/functionWithMultipleReturnStatements2.js index efee5816fb6..4674c6db953 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.js +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.js @@ -1,5 +1,4 @@ //// [functionWithMultipleReturnStatements2.ts] - // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols b/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols index 39cad6bc414..c4aa6663803 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts === - // return type of a function with multiple returns is the BCT of each return statement // no errors expected here @@ -14,7 +13,7 @@ function f1() { } function f2() { ->f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements2.ts, 10, 1)) +>f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements2.ts, 9, 1)) if (true) { return 1; @@ -26,13 +25,13 @@ function f2() { } function f4() { ->f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements2.ts, 20, 1)) +>f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements2.ts, 19, 1)) try { return 1; } catch (e) { ->e : Symbol(e, Decl(functionWithMultipleReturnStatements2.ts, 26, 11)) +>e : Symbol(e, Decl(functionWithMultipleReturnStatements2.ts, 25, 11)) return undefined; >undefined : Symbol(undefined) @@ -43,7 +42,7 @@ function f4() { } function f5() { ->f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements2.ts, 32, 1)) +>f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements2.ts, 31, 1)) return 1; return new Object(); @@ -51,14 +50,14 @@ function f5() { } function f6(x: T) { ->f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements2.ts, 37, 1)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 39, 12)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 39, 15)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 39, 12)) +>f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements2.ts, 36, 1)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 38, 12)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 38, 15)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 38, 12)) if (true) { return x; ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 39, 15)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 38, 15)) } else { return null; @@ -74,69 +73,69 @@ function f6(x: T) { //} var a: { x: number; y?: number }; ->a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 55, 8)) ->y : Symbol(y, Decl(functionWithMultipleReturnStatements2.ts, 55, 19)) +>a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 54, 3)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 54, 8)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements2.ts, 54, 19)) var b: { x: number; z?: number }; ->b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 56, 3)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 56, 8)) ->z : Symbol(z, Decl(functionWithMultipleReturnStatements2.ts, 56, 19)) +>b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 55, 8)) +>z : Symbol(z, Decl(functionWithMultipleReturnStatements2.ts, 55, 19)) // returns typeof a function f9() { ->f9 : Symbol(f9, Decl(functionWithMultipleReturnStatements2.ts, 56, 33)) +>f9 : Symbol(f9, Decl(functionWithMultipleReturnStatements2.ts, 55, 33)) if (true) { return a; ->a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) +>a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 54, 3)) } else { return b; ->b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 56, 3)) +>b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) } } // returns typeof b function f10() { ->f10 : Symbol(f10, Decl(functionWithMultipleReturnStatements2.ts, 64, 1)) +>f10 : Symbol(f10, Decl(functionWithMultipleReturnStatements2.ts, 63, 1)) if (true) { return b; ->b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 56, 3)) +>b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) } else { return a; ->a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) +>a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 54, 3)) } } // returns number => void function f11() { ->f11 : Symbol(f11, Decl(functionWithMultipleReturnStatements2.ts, 73, 1)) +>f11 : Symbol(f11, Decl(functionWithMultipleReturnStatements2.ts, 72, 1)) if (true) { return (x: number) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 78, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 77, 16)) } else { return (x: Object) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 80, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 79, 16)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } // returns Object => void function f12() { ->f12 : Symbol(f12, Decl(functionWithMultipleReturnStatements2.ts, 82, 1)) +>f12 : Symbol(f12, Decl(functionWithMultipleReturnStatements2.ts, 81, 1)) if (true) { return (x: Object) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 87, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 86, 16)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } else { return (x: number) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 89, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 88, 16)) } } diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.types b/tests/baselines/reference/functionWithMultipleReturnStatements2.types index 4615299bbf1..6608b0d00a9 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.types +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts === - // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.js b/tests/baselines/reference/functionWithNoBestCommonType1.js index 4d197c24334..f7114fb40d8 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.js +++ b/tests/baselines/reference/functionWithNoBestCommonType1.js @@ -1,5 +1,4 @@ //// [functionWithNoBestCommonType1.ts] - function foo() { return true; return bar(); diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.symbols b/tests/baselines/reference/functionWithNoBestCommonType1.symbols index 826b23f1b48..8185ba0239c 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.symbols +++ b/tests/baselines/reference/functionWithNoBestCommonType1.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/functionWithNoBestCommonType1.ts === - function foo() { >foo : Symbol(foo, Decl(functionWithNoBestCommonType1.ts, 0, 0)) return true; return bar(); ->bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 4, 1)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 3, 1)) } function bar(): void { ->bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 4, 1)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 3, 1)) } diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.types b/tests/baselines/reference/functionWithNoBestCommonType1.types index f93ffad3379..d1f87083438 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.types +++ b/tests/baselines/reference/functionWithNoBestCommonType1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionWithNoBestCommonType1.ts === - function foo() { >foo : () => true | void diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.js b/tests/baselines/reference/functionWithNoBestCommonType2.js index 06a133b2db8..8e903518ec0 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.js +++ b/tests/baselines/reference/functionWithNoBestCommonType2.js @@ -1,5 +1,4 @@ //// [functionWithNoBestCommonType2.ts] - var v = function () { return true; return bar(); diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.symbols b/tests/baselines/reference/functionWithNoBestCommonType2.symbols index f32f86e67a9..eb69c177866 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.symbols +++ b/tests/baselines/reference/functionWithNoBestCommonType2.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/functionWithNoBestCommonType2.ts === - var v = function () { ->v : Symbol(v, Decl(functionWithNoBestCommonType2.ts, 1, 3)) +>v : Symbol(v, Decl(functionWithNoBestCommonType2.ts, 0, 3)) return true; return bar(); ->bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 4, 2)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 3, 2)) }; function bar(): void { ->bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 4, 2)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 3, 2)) } diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.types b/tests/baselines/reference/functionWithNoBestCommonType2.types index 76fdbda535f..196419f084f 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.types +++ b/tests/baselines/reference/functionWithNoBestCommonType2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionWithNoBestCommonType2.ts === - var v = function () { >v : () => true | void >function () { return true; return bar();} : () => true | void diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt index e0c552141b2..e494e6593a0 100644 --- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt +++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt @@ -1,13 +1,11 @@ -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(3,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(101,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(106,16): error TS2378: A 'get' accessor must return a value. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(128,15): error TS2532: Object is possibly 'undefined'. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(129,5): error TS1003: Identifier expected. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(1,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(99,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(104,16): error TS2378: A 'get' accessor must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(126,15): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(127,5): error TS1003: Identifier expected. ==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ==== - - function f1(): string { ~~~~~~ !!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js index 17468722e20..3c10c77bef4 100644 --- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js +++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js @@ -1,6 +1,4 @@ //// [functionsMissingReturnStatementsAndExpressions.ts] - - function f1(): string { // errors because there are no return statements } diff --git a/tests/baselines/reference/generatedContextualTyping.js b/tests/baselines/reference/generatedContextualTyping.js index f8dc2863470..8b0889f28ae 100644 --- a/tests/baselines/reference/generatedContextualTyping.js +++ b/tests/baselines/reference/generatedContextualTyping.js @@ -1,5 +1,4 @@ //// [generatedContextualTyping.ts] - class Base { private p; } class Derived1 extends Base { private m; } class Derived2 extends Base { private n; } diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols index a31e38e8648..780170f24ed 100644 --- a/tests/baselines/reference/generatedContextualTyping.symbols +++ b/tests/baselines/reference/generatedContextualTyping.symbols @@ -1,2832 +1,2831 @@ === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts === - class Base { private p; } >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->p : Symbol(Base.p, Decl(generatedContextualTyping.ts, 1, 12)) +>p : Symbol(Base.p, Decl(generatedContextualTyping.ts, 0, 12)) class Derived1 extends Base { private m; } ->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25)) +>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->m : Symbol(Derived1.m, Decl(generatedContextualTyping.ts, 2, 29)) +>m : Symbol(Derived1.m, Decl(generatedContextualTyping.ts, 1, 29)) class Derived2 extends Base { private n; } ->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42)) +>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(Derived2.n, Decl(generatedContextualTyping.ts, 3, 29)) +>n : Symbol(Derived2.n, Decl(generatedContextualTyping.ts, 2, 29)) interface Genric { func(n: T[]); } ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) ->T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17)) ->func : Symbol(Genric.func, Decl(generatedContextualTyping.ts, 4, 21)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 4, 27)) ->T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17)) +>func : Symbol(Genric.func, Decl(generatedContextualTyping.ts, 3, 21)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 27)) +>T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17)) var b = new Base(), d1 = new Derived1(), d2 = new Derived2(); ->b : Symbol(b, Decl(generatedContextualTyping.ts, 5, 3)) +>b : Symbol(b, Decl(generatedContextualTyping.ts, 4, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42)) var x1: () => Base[] = () => [d1, d2]; ->x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 6, 3)) +>x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 5, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x2: () => Base[] = function() { return [d1, d2] }; ->x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 7, 3)) +>x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 6, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x3: () => Base[] = function named() { return [d1, d2] }; ->x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 8, 3)) +>x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 7, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 8, 22)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x4: { (): Base[]; } = () => [d1, d2]; ->x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 9, 3)) +>x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 8, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x5: { (): Base[]; } = function() { return [d1, d2] }; ->x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 10, 3)) +>x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 9, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x6: { (): Base[]; } = function named() { return [d1, d2] }; ->x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 11, 3)) +>x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 10, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 11, 25)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x7: Base[] = [d1, d2]; ->x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 12, 3)) +>x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 11, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x8: Array = [d1, d2]; ->x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 13, 3)) +>x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 12, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x9: { [n: number]: Base; } = [d1, d2]; ->x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 14, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 11)) +>x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 13, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 13, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x10: {n: Base[]; } = { n: [d1, d2] }; ->x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 15, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 10)) +>x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 14, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 10)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x11: (s: Base[]) => any = n => { var n: Base[]; return null; }; ->x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 16, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 16, 10)) +>x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 15, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 15, 10)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x12: Genric = { func: n => { return [d1, d2]; } }; ->x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 17, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 16, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 17, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 17, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 16, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x13 { member: () => Base[] = () => [d1, d2] } ->x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 17, 60)) ->member : Symbol(x13.member, Decl(generatedContextualTyping.ts, 18, 11)) +>x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 16, 60)) +>member : Symbol(x13.member, Decl(generatedContextualTyping.ts, 17, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x14 { member: () => Base[] = function() { return [d1, d2] } } ->x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 18, 51)) ->member : Symbol(x14.member, Decl(generatedContextualTyping.ts, 19, 11)) +>x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 17, 51)) +>member : Symbol(x14.member, Decl(generatedContextualTyping.ts, 18, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x15 { member: () => Base[] = function named() { return [d1, d2] } } ->x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 19, 67)) ->member : Symbol(x15.member, Decl(generatedContextualTyping.ts, 20, 11)) +>x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 18, 67)) +>member : Symbol(x15.member, Decl(generatedContextualTyping.ts, 19, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 20, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x16 { member: { (): Base[]; } = () => [d1, d2] } ->x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 20, 73)) ->member : Symbol(x16.member, Decl(generatedContextualTyping.ts, 21, 11)) +>x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 19, 73)) +>member : Symbol(x16.member, Decl(generatedContextualTyping.ts, 20, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x17 { member: { (): Base[]; } = function() { return [d1, d2] } } ->x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 21, 54)) ->member : Symbol(x17.member, Decl(generatedContextualTyping.ts, 22, 11)) +>x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 20, 54)) +>member : Symbol(x17.member, Decl(generatedContextualTyping.ts, 21, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } } ->x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 22, 70)) ->member : Symbol(x18.member, Decl(generatedContextualTyping.ts, 23, 11)) +>x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 21, 70)) +>member : Symbol(x18.member, Decl(generatedContextualTyping.ts, 22, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 23, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x19 { member: Base[] = [d1, d2] } ->x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 23, 76)) ->member : Symbol(x19.member, Decl(generatedContextualTyping.ts, 24, 11)) +>x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 22, 76)) +>member : Symbol(x19.member, Decl(generatedContextualTyping.ts, 23, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x20 { member: Array = [d1, d2] } ->x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 24, 39)) ->member : Symbol(x20.member, Decl(generatedContextualTyping.ts, 25, 11)) +>x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 23, 39)) +>member : Symbol(x20.member, Decl(generatedContextualTyping.ts, 24, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x21 { member: { [n: number]: Base; } = [d1, d2] } ->x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 25, 44)) ->member : Symbol(x21.member, Decl(generatedContextualTyping.ts, 26, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 23)) +>x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 24, 44)) +>member : Symbol(x21.member, Decl(generatedContextualTyping.ts, 25, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 25, 23)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x22 { member: {n: Base[]; } = { n: [d1, d2] } } ->x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 26, 55)) ->member : Symbol(x22.member, Decl(generatedContextualTyping.ts, 27, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 21)) +>x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 25, 55)) +>member : Symbol(x22.member, Decl(generatedContextualTyping.ts, 26, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 27, 54)) ->member : Symbol(x23.member, Decl(generatedContextualTyping.ts, 28, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 28, 21)) +>x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 26, 54)) +>member : Symbol(x23.member, Decl(generatedContextualTyping.ts, 27, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 27, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x24 { member: Genric = { func: n => { return [d1, d2]; } } } ->x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 28, 79)) ->member : Symbol(x24.member, Decl(generatedContextualTyping.ts, 29, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 27, 79)) +>member : Symbol(x24.member, Decl(generatedContextualTyping.ts, 28, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 29, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 29, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 28, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x25 { private member: () => Base[] = () => [d1, d2] } ->x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 29, 72)) ->member : Symbol(x25.member, Decl(generatedContextualTyping.ts, 30, 11)) +>x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 28, 72)) +>member : Symbol(x25.member, Decl(generatedContextualTyping.ts, 29, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x26 { private member: () => Base[] = function() { return [d1, d2] } } ->x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 30, 59)) ->member : Symbol(x26.member, Decl(generatedContextualTyping.ts, 31, 11)) +>x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 29, 59)) +>member : Symbol(x26.member, Decl(generatedContextualTyping.ts, 30, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x27 { private member: () => Base[] = function named() { return [d1, d2] } } ->x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 31, 75)) ->member : Symbol(x27.member, Decl(generatedContextualTyping.ts, 32, 11)) +>x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 30, 75)) +>member : Symbol(x27.member, Decl(generatedContextualTyping.ts, 31, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 32, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x28 { private member: { (): Base[]; } = () => [d1, d2] } ->x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 32, 81)) ->member : Symbol(x28.member, Decl(generatedContextualTyping.ts, 33, 11)) +>x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 31, 81)) +>member : Symbol(x28.member, Decl(generatedContextualTyping.ts, 32, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } } ->x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 33, 62)) ->member : Symbol(x29.member, Decl(generatedContextualTyping.ts, 34, 11)) +>x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 32, 62)) +>member : Symbol(x29.member, Decl(generatedContextualTyping.ts, 33, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } } ->x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 34, 78)) ->member : Symbol(x30.member, Decl(generatedContextualTyping.ts, 35, 11)) +>x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 33, 78)) +>member : Symbol(x30.member, Decl(generatedContextualTyping.ts, 34, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 35, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x31 { private member: Base[] = [d1, d2] } ->x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 35, 84)) ->member : Symbol(x31.member, Decl(generatedContextualTyping.ts, 36, 11)) +>x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 34, 84)) +>member : Symbol(x31.member, Decl(generatedContextualTyping.ts, 35, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x32 { private member: Array = [d1, d2] } ->x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 36, 47)) ->member : Symbol(x32.member, Decl(generatedContextualTyping.ts, 37, 11)) +>x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 35, 47)) +>member : Symbol(x32.member, Decl(generatedContextualTyping.ts, 36, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x33 { private member: { [n: number]: Base; } = [d1, d2] } ->x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 37, 52)) ->member : Symbol(x33.member, Decl(generatedContextualTyping.ts, 38, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 31)) +>x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 36, 52)) +>member : Symbol(x33.member, Decl(generatedContextualTyping.ts, 37, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 37, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x34 { private member: {n: Base[]; } = { n: [d1, d2] } } ->x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 38, 63)) ->member : Symbol(x34.member, Decl(generatedContextualTyping.ts, 39, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 29)) +>x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 37, 63)) +>member : Symbol(x34.member, Decl(generatedContextualTyping.ts, 38, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 39, 62)) ->member : Symbol(x35.member, Decl(generatedContextualTyping.ts, 40, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 40, 29)) +>x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 38, 62)) +>member : Symbol(x35.member, Decl(generatedContextualTyping.ts, 39, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 39, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x36 { private member: Genric = { func: n => { return [d1, d2]; } } } ->x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 40, 87)) ->member : Symbol(x36.member, Decl(generatedContextualTyping.ts, 41, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 39, 87)) +>member : Symbol(x36.member, Decl(generatedContextualTyping.ts, 40, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 41, 44)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 41, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 40, 44)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x37 { public member: () => Base[] = () => [d1, d2] } ->x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 41, 80)) ->member : Symbol(x37.member, Decl(generatedContextualTyping.ts, 42, 11)) +>x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 40, 80)) +>member : Symbol(x37.member, Decl(generatedContextualTyping.ts, 41, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x38 { public member: () => Base[] = function() { return [d1, d2] } } ->x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 42, 58)) ->member : Symbol(x38.member, Decl(generatedContextualTyping.ts, 43, 11)) +>x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 41, 58)) +>member : Symbol(x38.member, Decl(generatedContextualTyping.ts, 42, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x39 { public member: () => Base[] = function named() { return [d1, d2] } } ->x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 43, 74)) ->member : Symbol(x39.member, Decl(generatedContextualTyping.ts, 44, 11)) +>x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 42, 74)) +>member : Symbol(x39.member, Decl(generatedContextualTyping.ts, 43, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 44, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x40 { public member: { (): Base[]; } = () => [d1, d2] } ->x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 44, 80)) ->member : Symbol(x40.member, Decl(generatedContextualTyping.ts, 45, 11)) +>x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 43, 80)) +>member : Symbol(x40.member, Decl(generatedContextualTyping.ts, 44, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } } ->x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 45, 61)) ->member : Symbol(x41.member, Decl(generatedContextualTyping.ts, 46, 11)) +>x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 44, 61)) +>member : Symbol(x41.member, Decl(generatedContextualTyping.ts, 45, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } } ->x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 46, 77)) ->member : Symbol(x42.member, Decl(generatedContextualTyping.ts, 47, 11)) +>x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 45, 77)) +>member : Symbol(x42.member, Decl(generatedContextualTyping.ts, 46, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 47, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x43 { public member: Base[] = [d1, d2] } ->x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 47, 83)) ->member : Symbol(x43.member, Decl(generatedContextualTyping.ts, 48, 11)) +>x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 46, 83)) +>member : Symbol(x43.member, Decl(generatedContextualTyping.ts, 47, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x44 { public member: Array = [d1, d2] } ->x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 48, 46)) ->member : Symbol(x44.member, Decl(generatedContextualTyping.ts, 49, 11)) +>x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 47, 46)) +>member : Symbol(x44.member, Decl(generatedContextualTyping.ts, 48, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x45 { public member: { [n: number]: Base; } = [d1, d2] } ->x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 49, 51)) ->member : Symbol(x45.member, Decl(generatedContextualTyping.ts, 50, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 30)) +>x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 48, 51)) +>member : Symbol(x45.member, Decl(generatedContextualTyping.ts, 49, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 49, 30)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x46 { public member: {n: Base[]; } = { n: [d1, d2] } } ->x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 50, 62)) ->member : Symbol(x46.member, Decl(generatedContextualTyping.ts, 51, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 28)) +>x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 49, 62)) +>member : Symbol(x46.member, Decl(generatedContextualTyping.ts, 50, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 51, 61)) ->member : Symbol(x47.member, Decl(generatedContextualTyping.ts, 52, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 52, 28)) +>x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 50, 61)) +>member : Symbol(x47.member, Decl(generatedContextualTyping.ts, 51, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 51, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x48 { public member: Genric = { func: n => { return [d1, d2]; } } } ->x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 52, 86)) ->member : Symbol(x48.member, Decl(generatedContextualTyping.ts, 53, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 51, 86)) +>member : Symbol(x48.member, Decl(generatedContextualTyping.ts, 52, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 53, 43)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 53, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 52, 43)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x49 { static member: () => Base[] = () => [d1, d2] } ->x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 53, 79)) ->member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 54, 11)) +>x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 52, 79)) +>member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 53, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x50 { static member: () => Base[] = function() { return [d1, d2] } } ->x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 54, 58)) ->member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 55, 11)) +>x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 53, 58)) +>member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 54, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x51 { static member: () => Base[] = function named() { return [d1, d2] } } ->x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 55, 74)) ->member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 56, 11)) +>x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 54, 74)) +>member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 55, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 56, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x52 { static member: { (): Base[]; } = () => [d1, d2] } ->x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 56, 80)) ->member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 57, 11)) +>x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 55, 80)) +>member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 56, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } } ->x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 57, 61)) ->member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 58, 11)) +>x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 56, 61)) +>member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 57, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 58, 77)) ->member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 59, 11)) +>x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 57, 77)) +>member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 58, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 59, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x55 { static member: Base[] = [d1, d2] } ->x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 59, 83)) ->member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 60, 11)) +>x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 58, 83)) +>member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 59, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x56 { static member: Array = [d1, d2] } ->x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 60, 46)) ->member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 61, 11)) +>x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 59, 46)) +>member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 60, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x57 { static member: { [n: number]: Base; } = [d1, d2] } ->x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 61, 51)) ->member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 62, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 30)) +>x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 60, 51)) +>member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 61, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 61, 30)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x58 { static member: {n: Base[]; } = { n: [d1, d2] } } ->x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 62, 62)) ->member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 63, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 28)) +>x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 61, 62)) +>member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 62, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 63, 61)) ->member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 64, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 64, 28)) +>x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 62, 61)) +>member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 63, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 63, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x60 { static member: Genric = { func: n => { return [d1, d2]; } } } ->x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 64, 86)) ->member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 65, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 63, 86)) +>member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 64, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 65, 43)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 65, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 64, 43)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x61 { private static member: () => Base[] = () => [d1, d2] } ->x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 65, 79)) ->member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 66, 11)) +>x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 64, 79)) +>member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 65, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x62 { private static member: () => Base[] = function() { return [d1, d2] } } ->x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 66, 66)) ->member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 67, 11)) +>x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 65, 66)) +>member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 66, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x63 { private static member: () => Base[] = function named() { return [d1, d2] } } ->x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 67, 82)) ->member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 68, 11)) +>x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 66, 82)) +>member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 67, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 68, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x64 { private static member: { (): Base[]; } = () => [d1, d2] } ->x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 68, 88)) ->member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 69, 11)) +>x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 67, 88)) +>member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 68, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } } ->x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 69, 69)) ->member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 70, 11)) +>x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 68, 69)) +>member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 69, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 70, 85)) ->member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 71, 11)) +>x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 69, 85)) +>member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 70, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 71, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x67 { private static member: Base[] = [d1, d2] } ->x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 71, 91)) ->member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 72, 11)) +>x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 70, 91)) +>member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 71, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x68 { private static member: Array = [d1, d2] } ->x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 72, 54)) ->member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 73, 11)) +>x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 71, 54)) +>member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 72, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x69 { private static member: { [n: number]: Base; } = [d1, d2] } ->x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 73, 59)) ->member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 74, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 38)) +>x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 72, 59)) +>member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 73, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 73, 38)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x70 { private static member: {n: Base[]; } = { n: [d1, d2] } } ->x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 74, 70)) ->member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 75, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 36)) +>x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 73, 70)) +>member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 74, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 36)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 75, 69)) ->member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 76, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 76, 36)) +>x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 74, 69)) +>member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 75, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 75, 36)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x72 { private static member: Genric = { func: n => { return [d1, d2]; } } } ->x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 76, 94)) ->member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 77, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 75, 94)) +>member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 76, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 77, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 77, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 76, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x73 { public static member: () => Base[] = () => [d1, d2] } ->x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 77, 87)) ->member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 78, 11)) +>x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 76, 87)) +>member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 77, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x74 { public static member: () => Base[] = function() { return [d1, d2] } } ->x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 78, 65)) ->member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 79, 11)) +>x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 77, 65)) +>member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 78, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x75 { public static member: () => Base[] = function named() { return [d1, d2] } } ->x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 79, 81)) ->member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 80, 11)) +>x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 78, 81)) +>member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 79, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 80, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x76 { public static member: { (): Base[]; } = () => [d1, d2] } ->x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 80, 87)) ->member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 81, 11)) +>x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 79, 87)) +>member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 80, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } } ->x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 81, 68)) ->member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 82, 11)) +>x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 80, 68)) +>member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 81, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 82, 84)) ->member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 83, 11)) +>x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 81, 84)) +>member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 82, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 83, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x79 { public static member: Base[] = [d1, d2] } ->x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 83, 90)) ->member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 84, 11)) +>x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 82, 90)) +>member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 83, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x80 { public static member: Array = [d1, d2] } ->x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 84, 53)) ->member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 85, 11)) +>x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 83, 53)) +>member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 84, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x81 { public static member: { [n: number]: Base; } = [d1, d2] } ->x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 85, 58)) ->member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 86, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 37)) +>x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 84, 58)) +>member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 85, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 85, 37)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x82 { public static member: {n: Base[]; } = { n: [d1, d2] } } ->x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 86, 69)) ->member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 87, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 35)) +>x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 85, 69)) +>member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 86, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 35)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 87, 68)) ->member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 88, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 88, 35)) +>x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 86, 68)) +>member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 87, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 87, 35)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x84 { public static member: Genric = { func: n => { return [d1, d2]; } } } ->x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 88, 93)) ->member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 89, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 87, 93)) +>member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 88, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 89, 50)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 89, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 88, 50)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } } ->x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 89, 86)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24)) +>x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 88, 86)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 89, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } } ->x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 90, 66)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24)) +>x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 89, 66)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 91, 82)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24)) +>x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 90, 82)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 92, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } } ->x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 92, 88)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24)) +>x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 91, 88)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 93, 69)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24)) +>x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 92, 69)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 94, 85)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24)) +>x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 93, 85)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 95, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x91 { constructor(parm: Base[] = [d1, d2]) { } } ->x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 95, 91)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) +>x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 94, 91)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x92 { constructor(parm: Array = [d1, d2]) { } } ->x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 96, 54)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24)) +>x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 95, 54)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } } ->x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 97, 59)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 33)) +>x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 96, 59)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 97, 33)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x94 { constructor(parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 98, 70)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 31)) +>x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 97, 70)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 99, 69)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 100, 31)) +>x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 98, 69)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 99, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x96 { constructor(parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 100, 94)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 99, 94)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 101, 46)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 101, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 100, 46)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } } ->x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 101, 87)) ->parm : Symbol(x97.parm, Decl(generatedContextualTyping.ts, 102, 24)) +>x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 100, 87)) +>parm : Symbol(x97.parm, Decl(generatedContextualTyping.ts, 101, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } } ->x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 102, 73)) ->parm : Symbol(x98.parm, Decl(generatedContextualTyping.ts, 103, 24)) +>x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 101, 73)) +>parm : Symbol(x98.parm, Decl(generatedContextualTyping.ts, 102, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 103, 89)) ->parm : Symbol(x99.parm, Decl(generatedContextualTyping.ts, 104, 24)) +>x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 102, 89)) +>parm : Symbol(x99.parm, Decl(generatedContextualTyping.ts, 103, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 104, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } } ->x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 104, 95)) ->parm : Symbol(x100.parm, Decl(generatedContextualTyping.ts, 105, 25)) +>x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 103, 95)) +>parm : Symbol(x100.parm, Decl(generatedContextualTyping.ts, 104, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 105, 77)) ->parm : Symbol(x101.parm, Decl(generatedContextualTyping.ts, 106, 25)) +>x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 104, 77)) +>parm : Symbol(x101.parm, Decl(generatedContextualTyping.ts, 105, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 106, 93)) ->parm : Symbol(x102.parm, Decl(generatedContextualTyping.ts, 107, 25)) +>x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 105, 93)) +>parm : Symbol(x102.parm, Decl(generatedContextualTyping.ts, 106, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 107, 55)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x103 { constructor(public parm: Base[] = [d1, d2]) { } } ->x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 107, 99)) ->parm : Symbol(x103.parm, Decl(generatedContextualTyping.ts, 108, 25)) +>x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 106, 99)) +>parm : Symbol(x103.parm, Decl(generatedContextualTyping.ts, 107, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x104 { constructor(public parm: Array = [d1, d2]) { } } ->x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 108, 62)) ->parm : Symbol(x104.parm, Decl(generatedContextualTyping.ts, 109, 25)) +>x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 107, 62)) +>parm : Symbol(x104.parm, Decl(generatedContextualTyping.ts, 108, 25)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } } ->x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 109, 67)) ->parm : Symbol(x105.parm, Decl(generatedContextualTyping.ts, 110, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 41)) +>x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 108, 67)) +>parm : Symbol(x105.parm, Decl(generatedContextualTyping.ts, 109, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 109, 41)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x106 { constructor(public parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 110, 78)) ->parm : Symbol(x106.parm, Decl(generatedContextualTyping.ts, 111, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 39)) +>x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 109, 78)) +>parm : Symbol(x106.parm, Decl(generatedContextualTyping.ts, 110, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 39)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 111, 77)) ->parm : Symbol(x107.parm, Decl(generatedContextualTyping.ts, 112, 25)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 112, 39)) +>x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 110, 77)) +>parm : Symbol(x107.parm, Decl(generatedContextualTyping.ts, 111, 25)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 111, 39)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x108 { constructor(public parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 112, 102)) ->parm : Symbol(x108.parm, Decl(generatedContextualTyping.ts, 113, 25)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 111, 102)) +>parm : Symbol(x108.parm, Decl(generatedContextualTyping.ts, 112, 25)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 113, 54)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 113, 60)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 112, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 60)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } } ->x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 113, 95)) ->parm : Symbol(x109.parm, Decl(generatedContextualTyping.ts, 114, 25)) +>x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 112, 95)) +>parm : Symbol(x109.parm, Decl(generatedContextualTyping.ts, 113, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } } ->x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 114, 75)) ->parm : Symbol(x110.parm, Decl(generatedContextualTyping.ts, 115, 25)) +>x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 113, 75)) +>parm : Symbol(x110.parm, Decl(generatedContextualTyping.ts, 114, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 115, 91)) ->parm : Symbol(x111.parm, Decl(generatedContextualTyping.ts, 116, 25)) +>x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 114, 91)) +>parm : Symbol(x111.parm, Decl(generatedContextualTyping.ts, 115, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 116, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } } ->x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 116, 97)) ->parm : Symbol(x112.parm, Decl(generatedContextualTyping.ts, 117, 25)) +>x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 115, 97)) +>parm : Symbol(x112.parm, Decl(generatedContextualTyping.ts, 116, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 117, 78)) ->parm : Symbol(x113.parm, Decl(generatedContextualTyping.ts, 118, 25)) +>x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 116, 78)) +>parm : Symbol(x113.parm, Decl(generatedContextualTyping.ts, 117, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 118, 94)) ->parm : Symbol(x114.parm, Decl(generatedContextualTyping.ts, 119, 25)) +>x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 117, 94)) +>parm : Symbol(x114.parm, Decl(generatedContextualTyping.ts, 118, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 119, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x115 { constructor(private parm: Base[] = [d1, d2]) { } } ->x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 119, 100)) ->parm : Symbol(x115.parm, Decl(generatedContextualTyping.ts, 120, 25)) +>x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 118, 100)) +>parm : Symbol(x115.parm, Decl(generatedContextualTyping.ts, 119, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x116 { constructor(private parm: Array = [d1, d2]) { } } ->x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 120, 63)) ->parm : Symbol(x116.parm, Decl(generatedContextualTyping.ts, 121, 25)) +>x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 119, 63)) +>parm : Symbol(x116.parm, Decl(generatedContextualTyping.ts, 120, 25)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } } ->x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 121, 68)) ->parm : Symbol(x117.parm, Decl(generatedContextualTyping.ts, 122, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 42)) +>x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 120, 68)) +>parm : Symbol(x117.parm, Decl(generatedContextualTyping.ts, 121, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 121, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x118 { constructor(private parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 122, 79)) ->parm : Symbol(x118.parm, Decl(generatedContextualTyping.ts, 123, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 40)) +>x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 121, 79)) +>parm : Symbol(x118.parm, Decl(generatedContextualTyping.ts, 122, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 123, 78)) ->parm : Symbol(x119.parm, Decl(generatedContextualTyping.ts, 124, 25)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 124, 40)) +>x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 122, 78)) +>parm : Symbol(x119.parm, Decl(generatedContextualTyping.ts, 123, 25)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 123, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x120 { constructor(private parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 124, 103)) ->parm : Symbol(x120.parm, Decl(generatedContextualTyping.ts, 125, 25)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 123, 103)) +>parm : Symbol(x120.parm, Decl(generatedContextualTyping.ts, 124, 25)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 125, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 125, 61)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 124, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 61)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x121(parm: () => Base[] = () => [d1, d2]) { } ->x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 125, 96)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14)) +>x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 124, 96)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x122(parm: () => Base[] = function() { return [d1, d2] }) { } ->x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 126, 54)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14)) +>x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 125, 54)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x123(parm: () => Base[] = function named() { return [d1, d2] }) { } ->x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 127, 70)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14)) +>x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 126, 70)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 128, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x124(parm: { (): Base[]; } = () => [d1, d2]) { } ->x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 128, 76)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14)) +>x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 127, 76)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { } ->x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 129, 57)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14)) +>x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 128, 57)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } ->x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 130, 73)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14)) +>x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 129, 73)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 131, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x127(parm: Base[] = [d1, d2]) { } ->x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 131, 79)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) +>x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 130, 79)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x128(parm: Array = [d1, d2]) { } ->x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 132, 42)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14)) +>x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 131, 42)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x129(parm: { [n: number]: Base; } = [d1, d2]) { } ->x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 133, 47)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 23)) +>x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 132, 47)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 133, 23)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x130(parm: {n: Base[]; } = { n: [d1, d2] }) { } ->x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 134, 58)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 21)) +>x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 133, 58)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } ->x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 135, 57)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 136, 21)) +>x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 134, 57)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 135, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x132(parm: Genric = { func: n => { return [d1, d2]; } }) { } ->x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 136, 82)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 137, 14)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 135, 82)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 137, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 137, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 136, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x133(): () => Base[] { return () => [d1, d2]; } ->x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 137, 75)) +>x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 136, 75)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x134(): () => Base[] { return function() { return [d1, d2] }; } ->x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 138, 56)) +>x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 137, 56)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x135(): () => Base[] { return function named() { return [d1, d2] }; } ->x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 139, 72)) +>x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 138, 72)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 140, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x136(): { (): Base[]; } { return () => [d1, d2]; } ->x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 140, 78)) +>x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 139, 78)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x137(): { (): Base[]; } { return function() { return [d1, d2] }; } ->x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 141, 59)) +>x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 140, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; } ->x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 142, 75)) +>x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 141, 75)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 143, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x139(): Base[] { return [d1, d2]; } ->x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 143, 81)) +>x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 142, 81)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x140(): Array { return [d1, d2]; } ->x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 144, 44)) +>x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 143, 44)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x141(): { [n: number]: Base; } { return [d1, d2]; } ->x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 145, 49)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 20)) +>x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 144, 49)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 145, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x142(): {n: Base[]; } { return { n: [d1, d2] }; } ->x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 146, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 18)) +>x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 145, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; } ->x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 147, 59)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 148, 18)) +>x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 146, 59)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 147, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x144(): Genric { return { func: n => { return [d1, d2]; } }; } ->x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 148, 84)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 147, 84)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 149, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 149, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 148, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; } ->x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 149, 77)) +>x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 148, 77)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; } ->x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 150, 79)) +>x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 149, 79)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; } ->x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 151, 111)) +>x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 150, 111)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 83)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; } ->x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 152, 123)) +>x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 151, 123)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; } ->x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 153, 82)) +>x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 152, 82)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; } ->x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 154, 114)) +>x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 153, 114)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 86)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x151(): Base[] { return [d1, d2]; return [d1, d2]; } ->x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 155, 126)) +>x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 154, 126)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x152(): Array { return [d1, d2]; return [d1, d2]; } ->x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 156, 61)) +>x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 155, 61)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; } ->x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 157, 66)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 20)) +>x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 156, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 157, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x154(): {n: Base[]; } { return { n: [d1, d2] }; return { n: [d1, d2] }; } ->x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 158, 77)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 18)) +>x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 157, 77)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 66)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 66)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; } ->x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 159, 83)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 160, 18)) +>x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 158, 83)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 159, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x156(): Genric { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; } ->x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 160, 129)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 159, 129)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 84)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 90)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 84)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 90)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x157: () => () => Base[] = () => { return () => [d1, d2]; }; ->x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 162, 3)) +>x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 161, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; }; ->x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 163, 3)) +>x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 162, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; }; ->x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 164, 3)) +>x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 163, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 164, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; }; ->x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 165, 3)) +>x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 164, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; }; ->x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 166, 3)) +>x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 165, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; }; ->x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 167, 3)) +>x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 166, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 167, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x163: () => Base[] = () => { return [d1, d2]; }; ->x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 168, 3)) +>x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 167, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x164: () => Array = () => { return [d1, d2]; }; ->x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 169, 3)) +>x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; }; ->x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 170, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 19)) +>x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 169, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 169, 19)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x166: () => {n: Base[]; } = () => { return { n: [d1, d2] }; }; ->x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 171, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 17)) +>x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 170, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; }; ->x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 172, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 172, 17)) +>x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 171, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 171, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x168: () => Genric = () => { return { func: n => { return [d1, d2]; } }; }; ->x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 173, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 172, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 173, 47)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 173, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 172, 47)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x169: () => () => Base[] = function() { return () => [d1, d2]; }; ->x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 174, 3)) +>x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 173, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; }; ->x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 175, 3)) +>x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 174, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; }; ->x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 176, 3)) +>x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 175, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 176, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; }; ->x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 177, 3)) +>x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 176, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; }; ->x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 178, 3)) +>x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 177, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; }; ->x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 179, 3)) +>x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 178, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 179, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x175: () => Base[] = function() { return [d1, d2]; }; ->x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 180, 3)) +>x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 179, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x176: () => Array = function() { return [d1, d2]; }; ->x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 181, 3)) +>x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; }; ->x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 182, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 19)) +>x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 181, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 181, 19)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x178: () => {n: Base[]; } = function() { return { n: [d1, d2] }; }; ->x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 183, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 17)) +>x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 182, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 54)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 54)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; }; ->x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 184, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 184, 17)) +>x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 183, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 183, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x180: () => Genric = function() { return { func: n => { return [d1, d2]; } }; }; ->x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 185, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 184, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 185, 52)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 185, 58)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 184, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 58)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x181 { var t: () => Base[] = () => [d1, d2]; } ->x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 185, 90)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17)) +>x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 184, 90)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 185, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x182 { var t: () => Base[] = function() { return [d1, d2] }; } ->x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 186, 53)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17)) +>x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 185, 53)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x183 { var t: () => Base[] = function named() { return [d1, d2] }; } ->x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 187, 69)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17)) +>x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 186, 69)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 188, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x184 { var t: { (): Base[]; } = () => [d1, d2]; } ->x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 188, 75)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17)) +>x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 187, 75)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; } ->x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 189, 56)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17)) +>x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 188, 56)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; } ->x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 190, 72)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17)) +>x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 189, 72)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 191, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x187 { var t: Base[] = [d1, d2]; } ->x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 191, 78)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) +>x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 190, 78)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x188 { var t: Array = [d1, d2]; } ->x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 192, 41)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17)) +>x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 191, 41)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x189 { var t: { [n: number]: Base; } = [d1, d2]; } ->x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 193, 46)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 24)) +>x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 192, 46)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 193, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x190 { var t: {n: Base[]; } = { n: [d1, d2] }; } ->x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 194, 57)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 22)) +>x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 193, 57)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 22)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; } ->x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 195, 56)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 196, 22)) +>x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 194, 56)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 195, 22)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) module x192 { var t: Genric = { func: n => { return [d1, d2]; } }; } ->x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 196, 81)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 17)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 195, 81)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 197, 37)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 197, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 196, 37)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x193 { export var t: () => Base[] = () => [d1, d2]; } ->x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 197, 74)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24)) +>x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 196, 74)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x194 { export var t: () => Base[] = function() { return [d1, d2] }; } ->x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 198, 60)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24)) +>x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 197, 60)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; } ->x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 199, 76)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24)) +>x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 198, 76)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 200, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x196 { export var t: { (): Base[]; } = () => [d1, d2]; } ->x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 200, 82)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24)) +>x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 199, 82)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; } ->x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 201, 63)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24)) +>x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 200, 63)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; } ->x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 202, 79)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24)) +>x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 201, 79)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 203, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x199 { export var t: Base[] = [d1, d2]; } ->x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 203, 85)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) +>x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 202, 85)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x200 { export var t: Array = [d1, d2]; } ->x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 204, 48)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24)) +>x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 203, 48)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x201 { export var t: { [n: number]: Base; } = [d1, d2]; } ->x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 205, 53)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 31)) +>x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 204, 53)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 205, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x202 { export var t: {n: Base[]; } = { n: [d1, d2] }; } ->x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 206, 64)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 29)) +>x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 205, 64)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; } ->x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 207, 63)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 208, 29)) +>x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 206, 63)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 207, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) module x204 { export var t: Genric = { func: n => { return [d1, d2]; } }; } ->x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 208, 88)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 209, 24)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 207, 88)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 209, 44)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 209, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 208, 44)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x206 = <() => Base[]>function() { return [d1, d2] }; ->x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 210, 3)) +>x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 209, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x207 = <() => Base[]>function named() { return [d1, d2] }; ->x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 211, 3)) +>x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 210, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 211, 25)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x209 = <{ (): Base[]; }>function() { return [d1, d2] }; ->x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 212, 3)) +>x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 211, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x210 = <{ (): Base[]; }>function named() { return [d1, d2] }; ->x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 213, 3)) +>x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 212, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 213, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x211 = [d1, d2]; ->x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 214, 3)) +>x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 213, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x212 = >[d1, d2]; ->x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 215, 3)) +>x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 214, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x213 = <{ [n: number]: Base; }>[d1, d2]; ->x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 216, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 15)) +>x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 215, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 215, 15)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x214 = <{n: Base[]; } >{ n: [d1, d2] }; ->x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 217, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 13)) +>x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 216, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x216 = >{ func: n => { return [d1, d2]; } }; ->x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 218, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 217, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 218, 26)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 218, 32)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 217, 26)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 32)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] }; ->x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 219, 3)) +>x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 218, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] }; ->x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 220, 3)) +>x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 219, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 220, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] }; ->x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 221, 3)) +>x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 220, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] }; ->x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 222, 3)) +>x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 221, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 222, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x221 = (undefined) || [d1, d2]; ->x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 223, 3)) +>x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 222, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x222 = (>undefined) || [d1, d2]; ->x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 224, 3)) +>x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 223, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2]; ->x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 225, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 16)) +>x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 224, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 224, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] }; ->x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 226, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 14)) +>x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 225, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x225: () => Base[]; x225 = () => [d1, d2]; ->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3)) +>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x226: () => Base[]; x226 = function() { return [d1, d2] }; ->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3)) +>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x227: () => Base[]; x227 = function named() { return [d1, d2] }; ->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3)) +>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 229, 30)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x228: { (): Base[]; }; x228 = () => [d1, d2]; ->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3)) +>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x229: { (): Base[]; }; x229 = function() { return [d1, d2] }; ->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3)) +>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] }; ->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3)) +>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 232, 33)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x231: Base[]; x231 = [d1, d2]; ->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3)) +>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x232: Array; x232 = [d1, d2]; ->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3)) +>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x233: { [n: number]: Base; }; x233 = [d1, d2]; ->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 13)) +>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 234, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x234: {n: Base[]; } ; x234 = { n: [d1, d2] }; ->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 11)) +>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; }; ->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 237, 11)) +>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 236, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47)) +>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x236: Genric; x236 = { func: n => { return [d1, d2]; } }; ->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 238, 32)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 237, 32)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x237: { n: () => Base[]; } = { n: () => [d1, d2] }; ->x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 239, 3)) +>x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 238, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 11)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) + +var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } }; +>x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 239, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } }; ->x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 240, 3)) +var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } }; +>x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 240, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) - -var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } }; ->x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 241, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 34)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 241, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] }; ->x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 242, 3)) +>x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 241, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) + +var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } }; +>x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 242, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } }; ->x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 243, 3)) +var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } }; +>x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 243, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) - -var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } }; ->x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 244, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 37)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 244, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x243: { n: Base[]; } = { n: [d1, d2] }; ->x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 245, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11)) +>x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 244, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x244: { n: Array; } = { n: [d1, d2] }; ->x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 246, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11)) +>x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 245, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 33)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 33)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] }; ->x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 247, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 18)) +>x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 246, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } }; ->x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 248, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 16)) +>x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 247, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } }; ->x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 249, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 249, 16)) +>x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 248, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 248, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x248: { n: Genric; } = { n: { func: n => { return [d1, d2]; } } }; ->x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 250, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 249, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 34)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 250, 39)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 34)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 249, 39)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x252: { (): Base[]; }[] = [() => [d1, d2]]; ->x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 251, 3)) +>x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 250, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x253: { (): Base[]; }[] = [function() { return [d1, d2] }]; ->x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 252, 3)) +>x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 251, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }]; ->x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 253, 3)) +>x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 252, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 253, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x255: Base[][] = [[d1, d2]]; ->x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 254, 3)) +>x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 253, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x256: Array[] = [[d1, d2]]; ->x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 255, 3)) +>x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 254, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x257: { [n: number]: Base; }[] = [[d1, d2]]; ->x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 256, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 13)) +>x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 255, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 255, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x258: {n: Base[]; } [] = [{ n: [d1, d2] }]; ->x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 257, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 11)) +>x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 256, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x260: Genric[] = [{ func: n => { return [d1, d2]; } }]; ->x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 258, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 257, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 258, 29)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 258, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 257, 29)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x261: () => Base[] = function() { return [d1, d2] } || undefined; ->x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 259, 3)) +>x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 258, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x262: () => Base[] = function named() { return [d1, d2] } || undefined; ->x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 260, 3)) +>x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 259, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 260, 24)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined; ->x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 261, 3)) +>x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 260, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined; ->x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 262, 3)) +>x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 261, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 262, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x265: Base[] = [d1, d2] || undefined; ->x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 263, 3)) +>x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 262, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x266: Array = [d1, d2] || undefined; ->x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 264, 3)) +>x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 263, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x267: { [n: number]: Base; } = [d1, d2] || undefined; ->x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 265, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 13)) +>x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 264, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 264, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x268: {n: Base[]; } = { n: [d1, d2] } || undefined; ->x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 266, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 11)) +>x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 265, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x269: () => Base[] = undefined || function() { return [d1, d2] }; ->x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 267, 3)) +>x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 266, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x270: () => Base[] = undefined || function named() { return [d1, d2] }; ->x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 268, 3)) +>x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 267, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 268, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x271: { (): Base[]; } = undefined || function() { return [d1, d2] }; ->x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 269, 3)) +>x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 268, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] }; ->x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 270, 3)) +>x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 269, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 270, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x273: Base[] = undefined || [d1, d2]; ->x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 271, 3)) +>x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 270, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x274: Array = undefined || [d1, d2]; ->x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 272, 3)) +>x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 271, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x275: { [n: number]: Base; } = undefined || [d1, d2]; ->x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 273, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 13)) +>x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 272, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 272, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x276: {n: Base[]; } = undefined || { n: [d1, d2] }; ->x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 274, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 11)) +>x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 273, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] }; ->x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 275, 3)) +>x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 274, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] }; ->x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 276, 3)) +>x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 275, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 24)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 64)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] }; ->x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 277, 3)) +>x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 276, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] }; ->x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 278, 3)) +>x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 277, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 67)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x281: Base[] = [d1, d2] || [d1, d2]; ->x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 279, 3)) +>x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 278, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x282: Array = [d1, d2] || [d1, d2]; ->x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 280, 3)) +>x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 279, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2]; ->x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 281, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 13)) +>x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 280, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 280, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x284: {n: Base[]; } = { n: [d1, d2] } || { n: [d1, d2] }; ->x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 282, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 11)) +>x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 281, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2]; ->x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 283, 3)) +>x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 282, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] }; ->x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 284, 3)) +>x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 283, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] }; ->x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 285, 3)) +>x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 284, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 70)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2]; ->x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 286, 3)) +>x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 285, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] }; ->x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 287, 3)) +>x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 286, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] }; ->x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 288, 3)) +>x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 287, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 73)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x291: Base[] = true ? [d1, d2] : [d1, d2]; ->x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 289, 3)) +>x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 288, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x292: Array = true ? [d1, d2] : [d1, d2]; ->x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 290, 3)) +>x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 289, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2]; ->x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 291, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 13)) +>x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 290, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 290, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x294: {n: Base[]; } = true ? { n: [d1, d2] } : { n: [d1, d2] }; ->x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 292, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 11)) +>x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 291, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; }; ->x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 293, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 293, 11)) +>x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 292, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 292, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x296: Genric = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } }; ->x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 294, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 293, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 33)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 71)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 77)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 33)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 71)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 77)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x297: () => Base[] = true ? undefined : () => [d1, d2]; ->x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 295, 3)) +>x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 294, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x298: () => Base[] = true ? undefined : function() { return [d1, d2] }; ->x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 296, 3)) +>x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 295, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] }; ->x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 297, 3)) +>x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 296, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 297, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x300: { (): Base[]; } = true ? undefined : () => [d1, d2]; ->x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 298, 3)) +>x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 297, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] }; ->x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 299, 3)) +>x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 298, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] }; ->x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 300, 3)) +>x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 299, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 300, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x303: Base[] = true ? undefined : [d1, d2]; ->x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 301, 3)) +>x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 300, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x304: Array = true ? undefined : [d1, d2]; ->x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 302, 3)) +>x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 301, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x305: { [n: number]: Base; } = true ? undefined : [d1, d2]; ->x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 303, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 13)) +>x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 302, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 302, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x306: {n: Base[]; } = true ? undefined : { n: [d1, d2] }; ->x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 304, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 11)) +>x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 303, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; }; ->x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 305, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 305, 11)) +>x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 304, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 304, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x308: Genric = true ? undefined : { func: n => { return [d1, d2]; } }; ->x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 306, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 305, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 306, 45)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 306, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 305, 45)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x309: () => Base[] = true ? () => [d1, d2] : undefined; ->x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 307, 3)) +>x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 306, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined; ->x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 308, 3)) +>x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 307, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined; ->x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 309, 3)) +>x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 308, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 309, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined; ->x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 310, 3)) +>x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 309, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined; ->x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 311, 3)) +>x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 310, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined; ->x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 312, 3)) +>x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 311, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 312, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x315: Base[] = true ? [d1, d2] : undefined; ->x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 313, 3)) +>x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 312, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x316: Array = true ? [d1, d2] : undefined; ->x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 314, 3)) +>x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 313, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined; ->x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 315, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 13)) +>x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 314, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 314, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x318: {n: Base[]; } = true ? { n: [d1, d2] } : undefined; ->x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 316, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 11)) +>x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 315, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined; ->x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 317, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 317, 11)) +>x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 316, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 316, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) var x320: Genric = true ? { func: n => { return [d1, d2]; } } : undefined; ->x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 318, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 317, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 318, 33)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 317, 33)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) function x321(n: () => Base[]) { }; x321(() => [d1, d2]); ->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14)) +>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] }); ->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14)) +>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] }); ->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14)) +>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 321, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]); ->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14)) +>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] }); ->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14)) +>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }); ->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14)) +>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 324, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x327(n: Base[]) { }; x327([d1, d2]); ->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) +>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x328(n: Array) { }; x328([d1, d2]); ->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14)) +>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]); ->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 20)) +>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] }); ->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 18)) +>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; }); ->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 329, 18)) +>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 328, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57)) +>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x332(n: Genric) { }; x332({ func: n => { return [d1, d2]; } }); ->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 14)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 330, 42)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 329, 42)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]); ->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) +>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) ->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12)) +>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] }); ->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) +>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) ->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) +>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] }); ->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) +>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) ->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 333, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) +>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]); ->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) +>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) ->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) +>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] }); ->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) +>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) ->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) +>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] }); ->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) +>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) ->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 336, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) +>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x339 = (n: Base[]) => n; x339([d1, d2]); ->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) +>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) ->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) +>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x340 = (n: Array) => n; x340([d1, d2]); ->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) +>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) ->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) +>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]); ->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 18)) +>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) ->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) +>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] }); ->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 16)) +>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) ->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) +>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; }); ->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 341, 16)) +>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 340, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) ->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) +>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x344 = (n: Genric) => n; x344({ func: n => { return [d1, d2]; } }); ->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12)) ->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 342, 41)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) +>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 341, 41)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]); ->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20)) +>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] }); ->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20)) +>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] }); ->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20)) +>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 345, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]); ->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20)) +>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] }); ->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20)) +>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] }); ->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20)) +>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 348, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x351 = function(n: Base[]) { }; x351([d1, d2]); ->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) +>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x352 = function(n: Array) { }; x352([d1, d2]); ->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20)) +>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]); ->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 26)) +>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 26)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] }); ->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 24)) +>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; }); ->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 353, 24)) +>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 352, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63)) +>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x356 = function(n: Genric) { }; x356({ func: n => { return [d1, d2]; } }); ->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 20)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 354, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 54)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 353, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 54)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types index a9b350f8564..d2eed925591 100644 --- a/tests/baselines/reference/generatedContextualTyping.types +++ b/tests/baselines/reference/generatedContextualTyping.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts === - class Base { private p; } >Base : Base >p : any diff --git a/tests/baselines/reference/generatorTypeCheck47.errors.txt b/tests/baselines/reference/generatorTypeCheck47.errors.txt index f5264f7ce96..993285179bc 100644 --- a/tests/baselines/reference/generatorTypeCheck47.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck47.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts (1 errors) ==== - function* g() { } ~ !!! error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck47.js b/tests/baselines/reference/generatorTypeCheck47.js index b06fb96b435..003f195c221 100644 --- a/tests/baselines/reference/generatorTypeCheck47.js +++ b/tests/baselines/reference/generatorTypeCheck47.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck47.ts] - function* g() { } //// [generatorTypeCheck47.js] diff --git a/tests/baselines/reference/generatorTypeCheck48.errors.txt b/tests/baselines/reference/generatorTypeCheck48.errors.txt index c91626cd813..867a0c35f60 100644 --- a/tests/baselines/reference/generatorTypeCheck48.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck48.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts (1 errors) ==== - function* g() { ~ !!! error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. diff --git a/tests/baselines/reference/generatorTypeCheck48.js b/tests/baselines/reference/generatorTypeCheck48.js index 579d6dcf0e1..f4ce9fbb334 100644 --- a/tests/baselines/reference/generatorTypeCheck48.js +++ b/tests/baselines/reference/generatorTypeCheck48.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck48.ts] - function* g() { yield; } diff --git a/tests/baselines/reference/generatorTypeCheck49.js b/tests/baselines/reference/generatorTypeCheck49.js index b544c7e4225..aec462ca553 100644 --- a/tests/baselines/reference/generatorTypeCheck49.js +++ b/tests/baselines/reference/generatorTypeCheck49.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck49.ts] - function* g() { yield 0; } diff --git a/tests/baselines/reference/generatorTypeCheck49.symbols b/tests/baselines/reference/generatorTypeCheck49.symbols index d24deed3d80..3e0cedad0fd 100644 --- a/tests/baselines/reference/generatorTypeCheck49.symbols +++ b/tests/baselines/reference/generatorTypeCheck49.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts === - function* g() { >g : Symbol(g, Decl(generatorTypeCheck49.ts, 0, 0)) diff --git a/tests/baselines/reference/generatorTypeCheck49.types b/tests/baselines/reference/generatorTypeCheck49.types index cd9f3e82d09..6ac2b6acce8 100644 --- a/tests/baselines/reference/generatorTypeCheck49.types +++ b/tests/baselines/reference/generatorTypeCheck49.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts === - function* g() { >g : () => IterableIterator<0> diff --git a/tests/baselines/reference/generatorTypeCheck50.js b/tests/baselines/reference/generatorTypeCheck50.js index 856e3867ab6..44e072c4b5e 100644 --- a/tests/baselines/reference/generatorTypeCheck50.js +++ b/tests/baselines/reference/generatorTypeCheck50.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck50.ts] - function* g() { yield yield; } diff --git a/tests/baselines/reference/generatorTypeCheck50.symbols b/tests/baselines/reference/generatorTypeCheck50.symbols index 412a1ac1ea7..636de9b40d9 100644 --- a/tests/baselines/reference/generatorTypeCheck50.symbols +++ b/tests/baselines/reference/generatorTypeCheck50.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts === - function* g() { >g : Symbol(g, Decl(generatorTypeCheck50.ts, 0, 0)) diff --git a/tests/baselines/reference/generatorTypeCheck50.types b/tests/baselines/reference/generatorTypeCheck50.types index 342d7406dce..1b25ea004f8 100644 --- a/tests/baselines/reference/generatorTypeCheck50.types +++ b/tests/baselines/reference/generatorTypeCheck50.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts === - function* g() { >g : () => IterableIterator diff --git a/tests/baselines/reference/generatorTypeCheck51.errors.txt b/tests/baselines/reference/generatorTypeCheck51.errors.txt index f4fc5723a5e..b717b51803e 100644 --- a/tests/baselines/reference/generatorTypeCheck51.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck51.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts (1 errors) ==== - function* g() { ~ !!! error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. diff --git a/tests/baselines/reference/generatorTypeCheck51.js b/tests/baselines/reference/generatorTypeCheck51.js index f3519065c3d..1df4d23e2d3 100644 --- a/tests/baselines/reference/generatorTypeCheck51.js +++ b/tests/baselines/reference/generatorTypeCheck51.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck51.ts] - function* g() { function* h() { yield 0; diff --git a/tests/baselines/reference/genericArray0.js b/tests/baselines/reference/genericArray0.js index a6a4f9365d1..d288f18a995 100644 --- a/tests/baselines/reference/genericArray0.js +++ b/tests/baselines/reference/genericArray0.js @@ -1,6 +1,5 @@ //// [genericArray0.ts] - var x:number[]; diff --git a/tests/baselines/reference/genericArray0.symbols b/tests/baselines/reference/genericArray0.symbols index 8870d60cde8..b757cbf348c 100644 --- a/tests/baselines/reference/genericArray0.symbols +++ b/tests/baselines/reference/genericArray0.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/genericArray0.ts === - var x:number[]; ->x : Symbol(x, Decl(genericArray0.ts, 2, 3)) +>x : Symbol(x, Decl(genericArray0.ts, 1, 3)) var y = x; ->y : Symbol(y, Decl(genericArray0.ts, 5, 3)) ->x : Symbol(x, Decl(genericArray0.ts, 2, 3)) +>y : Symbol(y, Decl(genericArray0.ts, 4, 3)) +>x : Symbol(x, Decl(genericArray0.ts, 1, 3)) function map() { ->map : Symbol(map, Decl(genericArray0.ts, 5, 10)) ->U : Symbol(U, Decl(genericArray0.ts, 7, 13)) +>map : Symbol(map, Decl(genericArray0.ts, 4, 10)) +>U : Symbol(U, Decl(genericArray0.ts, 6, 13)) var ys: U[] = []; ->ys : Symbol(ys, Decl(genericArray0.ts, 8, 7)) ->U : Symbol(U, Decl(genericArray0.ts, 7, 13)) +>ys : Symbol(ys, Decl(genericArray0.ts, 7, 7)) +>U : Symbol(U, Decl(genericArray0.ts, 6, 13)) } diff --git a/tests/baselines/reference/genericArray0.types b/tests/baselines/reference/genericArray0.types index bf0155bb9ba..0583049c965 100644 --- a/tests/baselines/reference/genericArray0.types +++ b/tests/baselines/reference/genericArray0.types @@ -1,6 +1,5 @@ === tests/cases/compiler/genericArray0.ts === - var x:number[]; >x : number[] diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt index 428ebecf5b0..9f728e554a3 100644 --- a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt @@ -1,19 +1,18 @@ -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(24,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(23,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(53,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(52,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(69,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(68,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(85,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; (b: boolean): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(84,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; (b: boolean): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'boolean'. ==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts (4 errors) ==== - module m1 { interface Promise { then(cb: (x: T) => Promise): Promise; diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js index 9bfb6eec113..42ba2b3233c 100644 --- a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js @@ -1,5 +1,4 @@ //// [genericCallToOverloadedMethodWithOverloadedArguments.ts] - module m1 { interface Promise { then(cb: (x: T) => Promise): Promise; diff --git a/tests/baselines/reference/genericClassesInModule.js b/tests/baselines/reference/genericClassesInModule.js index e531e25ec7a..6ca65804d89 100644 --- a/tests/baselines/reference/genericClassesInModule.js +++ b/tests/baselines/reference/genericClassesInModule.js @@ -1,5 +1,4 @@ //// [genericClassesInModule.ts] - module Foo { export class B{ } diff --git a/tests/baselines/reference/genericClassesInModule.symbols b/tests/baselines/reference/genericClassesInModule.symbols index f097eac36f1..ac3a0eca4a2 100644 --- a/tests/baselines/reference/genericClassesInModule.symbols +++ b/tests/baselines/reference/genericClassesInModule.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/genericClassesInModule.ts === - module Foo { >Foo : Symbol(Foo, Decl(genericClassesInModule.ts, 0, 0)) export class B{ } ->B : Symbol(B, Decl(genericClassesInModule.ts, 1, 12)) ->T : Symbol(T, Decl(genericClassesInModule.ts, 3, 19)) +>B : Symbol(B, Decl(genericClassesInModule.ts, 0, 12)) +>T : Symbol(T, Decl(genericClassesInModule.ts, 2, 19)) export class A { } ->A : Symbol(A, Decl(genericClassesInModule.ts, 3, 24)) +>A : Symbol(A, Decl(genericClassesInModule.ts, 2, 24)) } var a = new Foo.B(); ->a : Symbol(a, Decl(genericClassesInModule.ts, 8, 3)) ->Foo.B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 1, 12)) +>a : Symbol(a, Decl(genericClassesInModule.ts, 7, 3)) +>Foo.B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 0, 12)) >Foo : Symbol(Foo, Decl(genericClassesInModule.ts, 0, 0)) ->B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 1, 12)) +>B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 0, 12)) >Foo : Symbol(Foo, Decl(genericClassesInModule.ts, 0, 0)) ->A : Symbol(Foo.A, Decl(genericClassesInModule.ts, 3, 24)) +>A : Symbol(Foo.A, Decl(genericClassesInModule.ts, 2, 24)) diff --git a/tests/baselines/reference/genericClassesInModule.types b/tests/baselines/reference/genericClassesInModule.types index 128decac570..819a1f30256 100644 --- a/tests/baselines/reference/genericClassesInModule.types +++ b/tests/baselines/reference/genericClassesInModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/genericClassesInModule.ts === - module Foo { >Foo : typeof Foo diff --git a/tests/baselines/reference/genericDefaultsErrors.errors.txt b/tests/baselines/reference/genericDefaultsErrors.errors.txt index 03769586b41..3d792f022ac 100644 --- a/tests/baselines/reference/genericDefaultsErrors.errors.txt +++ b/tests/baselines/reference/genericDefaultsErrors.errors.txt @@ -1,30 +1,29 @@ -tests/cases/compiler/genericDefaultsErrors.ts(4,41): error TS2344: Type 'number' does not satisfy the constraint 'string'. -tests/cases/compiler/genericDefaultsErrors.ts(5,59): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(3,41): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/compiler/genericDefaultsErrors.ts(4,59): error TS2344: Type 'T' does not satisfy the constraint 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(6,44): error TS2344: Type 'T' does not satisfy the constraint 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(7,39): error TS2344: Type 'number' does not satisfy the constraint 'T'. -tests/cases/compiler/genericDefaultsErrors.ts(11,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/genericDefaultsErrors.ts(14,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/genericDefaultsErrors.ts(18,13): error TS2345: Argument of type '"a"' is not assignable to parameter of type 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(5,44): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(6,39): error TS2344: Type 'number' does not satisfy the constraint 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(10,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/genericDefaultsErrors.ts(13,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/genericDefaultsErrors.ts(17,13): error TS2345: Argument of type '"a"' is not assignable to parameter of type 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(19,11): error TS2428: All declarations of 'i00' must have identical type parameters. tests/cases/compiler/genericDefaultsErrors.ts(20,11): error TS2428: All declarations of 'i00' must have identical type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(21,11): error TS2428: All declarations of 'i00' must have identical type parameters. +tests/cases/compiler/genericDefaultsErrors.ts(22,11): error TS2428: All declarations of 'i01' must have identical type parameters. tests/cases/compiler/genericDefaultsErrors.ts(23,11): error TS2428: All declarations of 'i01' must have identical type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(24,11): error TS2428: All declarations of 'i01' must have identical type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(26,27): error TS2706: Required type parameters may not follow optional type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(27,34): error TS2344: Type 'number' does not satisfy the constraint 'string'. -tests/cases/compiler/genericDefaultsErrors.ts(28,52): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(25,27): error TS2706: Required type parameters may not follow optional type parameters. +tests/cases/compiler/genericDefaultsErrors.ts(26,34): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/compiler/genericDefaultsErrors.ts(27,52): error TS2344: Type 'T' does not satisfy the constraint 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(29,37): error TS2344: Type 'T' does not satisfy the constraint 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(30,32): error TS2344: Type 'number' does not satisfy the constraint 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(28,37): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(29,32): error TS2344: Type 'number' does not satisfy the constraint 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(32,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. tests/cases/compiler/genericDefaultsErrors.ts(33,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. -tests/cases/compiler/genericDefaultsErrors.ts(34,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. -tests/cases/compiler/genericDefaultsErrors.ts(37,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. -tests/cases/compiler/genericDefaultsErrors.ts(39,20): error TS2304: Cannot find name 'T'. -tests/cases/compiler/genericDefaultsErrors.ts(39,20): error TS4033: Property 'x' of exported interface has or is using private name 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(36,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. +tests/cases/compiler/genericDefaultsErrors.ts(38,20): error TS2304: Cannot find name 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(38,20): error TS4033: Property 'x' of exported interface has or is using private name 'T'. ==== tests/cases/compiler/genericDefaultsErrors.ts (21 errors) ==== - declare const x: any; declare function f03(): void; // error diff --git a/tests/baselines/reference/genericDefaultsErrors.js b/tests/baselines/reference/genericDefaultsErrors.js index 6309b01cab3..c737644e999 100644 --- a/tests/baselines/reference/genericDefaultsErrors.js +++ b/tests/baselines/reference/genericDefaultsErrors.js @@ -1,5 +1,4 @@ //// [genericDefaultsErrors.ts] - declare const x: any; declare function f03(): void; // error diff --git a/tests/baselines/reference/giant.errors.txt b/tests/baselines/reference/giant.errors.txt index 2c7e6f505bd..809ae036358 100644 --- a/tests/baselines/reference/giant.errors.txt +++ b/tests/baselines/reference/giant.errors.txt @@ -1,272 +1,271 @@ -tests/cases/compiler/giant.ts(23,12): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(24,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(24,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(25,12): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(26,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(26,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(27,13): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(28,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(28,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(29,13): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(30,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(30,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(33,12): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(34,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(34,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(35,12): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(36,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(36,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(61,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(61,6): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(62,5): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(63,6): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(76,5): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(87,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(88,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(88,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(89,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(90,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(90,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(91,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(92,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(92,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(93,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(94,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(94,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(97,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(98,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(98,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(99,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(100,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(100,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(125,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(125,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(126,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(127,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(140,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(154,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(166,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(167,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(167,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(168,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(169,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(169,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(170,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(171,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(171,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(172,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(173,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(173,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(176,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(177,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(177,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(178,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(179,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(179,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(204,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(204,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(205,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(206,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(219,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(233,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(238,35): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(240,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(243,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(22,12): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(23,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(23,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(24,12): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(25,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(25,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(26,13): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(27,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(27,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(28,13): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(29,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(29,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(32,12): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(33,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(33,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(34,12): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(35,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(35,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(60,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(60,6): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(61,5): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(62,6): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(75,5): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(86,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(87,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(87,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(88,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(89,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(89,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(90,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(91,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(91,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(92,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(93,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(93,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(96,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(97,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(97,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(98,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(99,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(99,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(124,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(124,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(125,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(126,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(139,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(153,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(165,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(166,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(166,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(167,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(168,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(168,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(169,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(170,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(170,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(171,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(172,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(172,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(175,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(176,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(176,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(177,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(178,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(178,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(203,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(203,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(204,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(205,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(218,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(232,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(237,35): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(239,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(242,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(243,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(244,16): error TS2300: Duplicate identifier 'pgF'. tests/cases/compiler/giant.ts(244,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(245,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(245,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(246,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(246,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(247,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(247,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(248,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(248,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(249,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(249,23): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(250,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(250,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(251,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(251,32): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(252,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(252,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(254,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(255,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(255,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(256,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(256,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(257,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(257,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(258,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(258,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(262,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(262,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(267,30): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(281,12): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(282,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(282,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(283,12): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(284,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(284,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(285,13): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(286,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(286,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(287,13): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(288,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(288,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(291,12): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(292,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(292,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(293,12): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(294,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(294,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(319,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(319,6): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(320,5): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(321,6): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(334,5): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(345,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(346,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(346,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(347,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(348,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(348,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(349,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(350,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(350,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(351,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(352,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(352,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(355,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(356,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(356,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(357,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(358,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(358,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(383,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(383,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(384,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(385,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(398,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(412,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(424,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(425,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(425,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(426,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(427,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(427,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(428,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(429,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(429,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(430,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(431,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(431,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(434,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(435,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(435,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(436,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(437,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(437,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(462,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(462,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(463,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(464,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(477,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(491,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(496,35): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(498,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(501,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(245,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(245,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(246,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(246,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(247,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(247,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(248,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(248,23): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(249,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(249,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(250,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(250,32): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(251,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(251,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(253,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(254,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(254,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(255,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(255,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(256,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(256,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(257,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(257,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(261,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(261,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(266,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(280,12): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(281,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(281,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(282,12): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(283,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(283,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(284,13): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(285,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(285,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(286,13): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(287,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(287,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(290,12): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(291,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(291,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(292,12): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(293,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(293,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(318,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(318,6): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(319,5): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(320,6): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(333,5): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(344,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(345,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(345,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(346,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(347,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(347,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(348,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(349,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(349,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(350,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(351,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(351,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(354,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(355,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(355,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(356,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(357,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(357,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(382,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(382,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(383,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(384,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(397,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(411,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(423,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(424,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(424,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(425,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(426,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(426,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(427,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(428,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(428,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(429,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(430,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(430,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(433,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(434,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(434,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(435,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(436,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(436,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(461,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(461,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(462,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(463,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(476,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(490,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(495,35): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(497,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(500,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(501,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(502,16): error TS2300: Duplicate identifier 'pgF'. tests/cases/compiler/giant.ts(502,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(503,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(503,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(504,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(504,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(505,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(505,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(506,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(506,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(507,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(507,23): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(508,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(508,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(509,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(509,32): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(510,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(510,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(512,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(513,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(513,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(514,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(514,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(515,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(515,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(516,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(516,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(520,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(520,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(525,30): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(532,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(534,20): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(537,17): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(503,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(503,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(504,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(504,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(505,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(505,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(506,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(506,23): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(507,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(507,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(508,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(508,32): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(509,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(509,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(511,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(512,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(512,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(513,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(513,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(514,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(514,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(515,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(515,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(519,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(519,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(524,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(531,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(533,20): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(536,17): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(537,18): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(538,12): error TS2300: Duplicate identifier 'pgF'. tests/cases/compiler/giant.ts(538,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(539,12): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(539,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(540,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(540,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(541,12): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(541,27): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(542,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(542,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(543,13): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(543,19): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(544,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(544,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(545,13): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(545,28): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(546,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(546,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(548,17): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(549,12): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(549,27): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(550,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(550,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(551,12): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(551,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(552,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(552,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(556,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(556,21): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(558,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(561,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(563,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(587,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(587,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(588,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(589,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(602,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(606,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(606,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(611,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(539,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(539,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(540,12): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(540,27): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(541,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(541,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(542,13): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(542,19): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(543,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(543,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(544,13): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(544,28): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(545,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(545,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(547,17): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(548,12): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(548,27): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(549,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(549,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(550,12): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(550,18): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(551,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(551,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(555,18): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(555,21): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(557,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(560,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(562,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(586,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(586,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(587,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(588,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(601,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(605,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(605,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(610,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(614,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. tests/cases/compiler/giant.ts(615,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/giant.ts(615,39): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/compiler/giant.ts(616,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/giant.ts(616,39): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/compiler/giant.ts(617,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/giant.ts(618,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/giant.ts(621,26): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(623,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(626,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(628,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(653,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(653,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(654,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(655,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(668,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(672,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(672,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(676,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(620,26): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(622,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(625,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(627,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(652,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(652,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(653,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(654,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(667,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(671,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(671,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(675,30): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/giant.ts (265 errors) ==== - /* Prefixes p -> public diff --git a/tests/baselines/reference/giant.js b/tests/baselines/reference/giant.js index ce4df039932..71f78eeac53 100644 --- a/tests/baselines/reference/giant.js +++ b/tests/baselines/reference/giant.js @@ -1,5 +1,4 @@ //// [giant.ts] - /* Prefixes p -> public diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.js b/tests/baselines/reference/globalAugmentationModuleResolution.js index 6dd87de81fd..fae150bb709 100644 --- a/tests/baselines/reference/globalAugmentationModuleResolution.js +++ b/tests/baselines/reference/globalAugmentationModuleResolution.js @@ -1,5 +1,4 @@ //// [a.ts] - export { }; declare global { diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.symbols b/tests/baselines/reference/globalAugmentationModuleResolution.symbols index 614860d654e..567c7e2b4f0 100644 --- a/tests/baselines/reference/globalAugmentationModuleResolution.symbols +++ b/tests/baselines/reference/globalAugmentationModuleResolution.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/externalModules/a.ts === - export { }; declare global { ->global : Symbol(global, Decl(a.ts, 1, 11)) +>global : Symbol(global, Decl(a.ts, 0, 11)) var x: number; ->x : Symbol(x, Decl(a.ts, 4, 5)) +>x : Symbol(x, Decl(a.ts, 3, 5)) } diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.types b/tests/baselines/reference/globalAugmentationModuleResolution.types index 75f23b0cd6b..8d9bf23bcc2 100644 --- a/tests/baselines/reference/globalAugmentationModuleResolution.types +++ b/tests/baselines/reference/globalAugmentationModuleResolution.types @@ -1,5 +1,4 @@ === tests/cases/conformance/externalModules/a.ts === - export { }; declare global { diff --git a/tests/baselines/reference/ifDoWhileStatements.js b/tests/baselines/reference/ifDoWhileStatements.js index 22dd78a9687..711ce1315dc 100644 --- a/tests/baselines/reference/ifDoWhileStatements.js +++ b/tests/baselines/reference/ifDoWhileStatements.js @@ -1,5 +1,4 @@ //// [ifDoWhileStatements.ts] - interface I { id: number; } diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols index b0ec471aa48..32a5437aac7 100644 --- a/tests/baselines/reference/ifDoWhileStatements.symbols +++ b/tests/baselines/reference/ifDoWhileStatements.symbols @@ -1,93 +1,92 @@ === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts === - interface I { >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) id: number; ->id : Symbol(I.id, Decl(ifDoWhileStatements.ts, 1, 13)) +>id : Symbol(I.id, Decl(ifDoWhileStatements.ts, 0, 13)) } class C implements I { ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) id: number; ->id : Symbol(C.id, Decl(ifDoWhileStatements.ts, 5, 22)) +>id : Symbol(C.id, Decl(ifDoWhileStatements.ts, 4, 22)) name: string; ->name : Symbol(C.name, Decl(ifDoWhileStatements.ts, 6, 15)) +>name : Symbol(C.name, Decl(ifDoWhileStatements.ts, 5, 15)) } class C2 extends C { ->C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 8, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 7, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) valid: boolean; ->valid : Symbol(C2.valid, Decl(ifDoWhileStatements.ts, 10, 20)) +>valid : Symbol(C2.valid, Decl(ifDoWhileStatements.ts, 9, 20)) } class D{ ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) source: T; ->source : Symbol(D.source, Decl(ifDoWhileStatements.ts, 14, 11)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>source : Symbol(D.source, Decl(ifDoWhileStatements.ts, 13, 11)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) recurse: D; ->recurse : Symbol(D.recurse, Decl(ifDoWhileStatements.ts, 15, 14)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>recurse : Symbol(D.recurse, Decl(ifDoWhileStatements.ts, 14, 14)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) wrapped: D> ->wrapped : Symbol(D.wrapped, Decl(ifDoWhileStatements.ts, 16, 18)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>wrapped : Symbol(D.wrapped, Decl(ifDoWhileStatements.ts, 15, 18)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(ifDoWhileStatements.ts, 18, 1)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 11)) +>F : Symbol(F, Decl(ifDoWhileStatements.ts, 17, 1)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 19, 11)) function F2(x: number): boolean { return x < 42; } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 20, 44)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 19, 44)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12)) module M { ->M : Symbol(M, Decl(ifDoWhileStatements.ts, 21, 50)) +>M : Symbol(M, Decl(ifDoWhileStatements.ts, 20, 50)) export class A { ->A : Symbol(A, Decl(ifDoWhileStatements.ts, 23, 10)) +>A : Symbol(A, Decl(ifDoWhileStatements.ts, 22, 10)) name: string; ->name : Symbol(A.name, Decl(ifDoWhileStatements.ts, 24, 20)) +>name : Symbol(A.name, Decl(ifDoWhileStatements.ts, 23, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 26, 5)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 25, 5)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } module N { ->N : Symbol(N, Decl(ifDoWhileStatements.ts, 29, 1)) +>N : Symbol(N, Decl(ifDoWhileStatements.ts, 28, 1)) export class A { ->A : Symbol(A, Decl(ifDoWhileStatements.ts, 31, 10)) +>A : Symbol(A, Decl(ifDoWhileStatements.ts, 30, 10)) id: number; ->id : Symbol(A.id, Decl(ifDoWhileStatements.ts, 32, 20)) +>id : Symbol(A.id, Decl(ifDoWhileStatements.ts, 31, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 34, 5)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 33, 5)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } @@ -138,200 +137,200 @@ while ({}) { } do { }while({}) if ({ x: 1, y: 'a' }) { } ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 5)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 11)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 79, 5)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 79, 11)) while ({ x: 1, y: 'a' }) { } ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 8)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 14)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 8)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 14)) do { }while({ x: 1, y: 'a' }) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 82, 13)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 82, 19)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 13)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 19)) if (() => 43) { } while (() => 43) { } do { }while(() => 43) if (new C()) { } ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) while (new C()) { } ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) do { }while(new C()) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) if (new D()) { } ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) while (new D()) { } ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) do { }while(new D()) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) // references var a = true; ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) if (a) { } ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) while (a) { } ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) do { }while(a) ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) var b = null; ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) if (b) { } ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) while (b) { } ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) do { }while(b) ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) var c = undefined; ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) >undefined : Symbol(undefined) if (c) { } ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) while (c) { } ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) do { }while(c) ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) var d = 0.0; ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) if (d) { } ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) while (d) { } ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) do { }while(d) ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) var e = 'a string'; ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) if (e) { } ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) while (e) { } ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) do { }while(e) ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) var f = ''; ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) if (f) { } ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) while (f) { } ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) do { }while(f) ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) var g = /[a-z]/ ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) if (g) { } ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) while (g) { } ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) do { }while(g) ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) var h = []; ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) if (h) { } ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) while (h) { } ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) do { }while(h) ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) var i = [1, 2]; ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) if (i) { } ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) while (i) { } ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) do { }while(i) ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) var j = {}; ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) if (j) { } ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) while (j) { } ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) do { }while(j) ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) var k = { x: 1, y: 'a' }; ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 147, 9)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 147, 15)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 146, 9)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 146, 15)) if (k) { } ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) while (k) { } ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) do { }while(k) ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) function fn(x?: string): I { return null; } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 152, 12)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 151, 12)) >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) if (fn()) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) while (fn()) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) do { }while(fn()) ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) if (fn) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) while (fn) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) do { }while(fn) ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) diff --git a/tests/baselines/reference/ifDoWhileStatements.types b/tests/baselines/reference/ifDoWhileStatements.types index eee459391c5..801b4d35f2f 100644 --- a/tests/baselines/reference/ifDoWhileStatements.types +++ b/tests/baselines/reference/ifDoWhileStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts === - interface I { >I : I diff --git a/tests/baselines/reference/ifElseWithStatements1.errors.txt b/tests/baselines/reference/ifElseWithStatements1.errors.txt index 5dc4d9b0db5..186cff59241 100644 --- a/tests/baselines/reference/ifElseWithStatements1.errors.txt +++ b/tests/baselines/reference/ifElseWithStatements1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/ifElseWithStatements1.ts(3,5): error TS2304: Cannot find name 'f'. -tests/cases/compiler/ifElseWithStatements1.ts(5,5): error TS2304: Cannot find name 'f'. +tests/cases/compiler/ifElseWithStatements1.ts(2,5): error TS2304: Cannot find name 'f'. +tests/cases/compiler/ifElseWithStatements1.ts(4,5): error TS2304: Cannot find name 'f'. ==== tests/cases/compiler/ifElseWithStatements1.ts (2 errors) ==== - if (true) f(); ~ diff --git a/tests/baselines/reference/ifElseWithStatements1.js b/tests/baselines/reference/ifElseWithStatements1.js index 47df08d46ba..506e7e6a330 100644 --- a/tests/baselines/reference/ifElseWithStatements1.js +++ b/tests/baselines/reference/ifElseWithStatements1.js @@ -1,5 +1,4 @@ //// [ifElseWithStatements1.ts] - if (true) f(); else diff --git a/tests/baselines/reference/implicitAnyAmbients.errors.txt b/tests/baselines/reference/implicitAnyAmbients.errors.txt index d425edbfefd..07c69b75a9b 100644 --- a/tests/baselines/reference/implicitAnyAmbients.errors.txt +++ b/tests/baselines/reference/implicitAnyAmbients.errors.txt @@ -1,16 +1,15 @@ -tests/cases/compiler/implicitAnyAmbients.ts(3,9): error TS7005: Variable 'x' implicitly has an 'any' type. -tests/cases/compiler/implicitAnyAmbients.ts(6,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(6,16): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/implicitAnyAmbients.ts(7,14): error TS7010: 'f2', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(11,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(12,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(17,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(18,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(23,13): error TS7005: Variable 'y' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyAmbients.ts(2,9): error TS7005: Variable 'x' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyAmbients.ts(5,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(5,16): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyAmbients.ts(6,14): error TS7010: 'f2', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(10,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(11,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(16,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(17,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(22,13): error TS7005: Variable 'y' implicitly has an 'any' type. ==== tests/cases/compiler/implicitAnyAmbients.ts (9 errors) ==== - declare module m { var x; // error ~ diff --git a/tests/baselines/reference/implicitAnyAmbients.js b/tests/baselines/reference/implicitAnyAmbients.js index 6b63bf8b819..fe832c279b6 100644 --- a/tests/baselines/reference/implicitAnyAmbients.js +++ b/tests/baselines/reference/implicitAnyAmbients.js @@ -1,5 +1,4 @@ //// [implicitAnyAmbients.ts] - declare module m { var x; // error var y: any; diff --git a/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt b/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt index bb43d96b003..d083fe97664 100644 --- a/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt +++ b/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt @@ -1,18 +1,17 @@ -tests/cases/compiler/implicitAnyFromCircularInference.ts(3,5): error TS2502: 'a' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(6,5): error TS2502: 'b' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(7,5): error TS2502: 'c' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(10,5): error TS2502: 'd' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(15,10): error TS7023: 'g' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(18,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(23,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(26,10): error TS7023: 'h' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(28,14): error TS7023: 'foo' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(41,5): error TS7022: 's' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -tests/cases/compiler/implicitAnyFromCircularInference.ts(46,9): error TS7023: 'x' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(2,5): error TS2502: 'a' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(5,5): error TS2502: 'b' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(6,5): error TS2502: 'c' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(9,5): error TS2502: 'd' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(14,10): error TS7023: 'g' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(17,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(22,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(25,10): error TS7023: 'h' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(27,14): error TS7023: 'foo' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(40,5): error TS7022: 's' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +tests/cases/compiler/implicitAnyFromCircularInference.ts(45,9): error TS7023: 'x' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. ==== tests/cases/compiler/implicitAnyFromCircularInference.ts (11 errors) ==== - // Error expected var a: typeof a; ~ diff --git a/tests/baselines/reference/implicitAnyFromCircularInference.js b/tests/baselines/reference/implicitAnyFromCircularInference.js index 9fa4f3ff225..b55db223c75 100644 --- a/tests/baselines/reference/implicitAnyFromCircularInference.js +++ b/tests/baselines/reference/implicitAnyFromCircularInference.js @@ -1,5 +1,4 @@ //// [implicitAnyFromCircularInference.ts] - // Error expected var a: typeof a; diff --git a/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt b/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt index c479d06d898..0c64c3e6125 100644 --- a/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt +++ b/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/implicitAnyGenericTypeInference.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/implicitAnyGenericTypeInference.ts(7,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyGenericTypeInference.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyGenericTypeInference.ts(6,22): error TS7006: Parameter 'y' implicitly has an 'any' type. ==== tests/cases/compiler/implicitAnyGenericTypeInference.ts (2 errors) ==== - interface Comparer { compareTo(x: T, y: U): U; } diff --git a/tests/baselines/reference/implicitAnyGenericTypeInference.js b/tests/baselines/reference/implicitAnyGenericTypeInference.js index 583ab7f0b01..49c94b68f60 100644 --- a/tests/baselines/reference/implicitAnyGenericTypeInference.js +++ b/tests/baselines/reference/implicitAnyGenericTypeInference.js @@ -1,5 +1,4 @@ //// [implicitAnyGenericTypeInference.ts] - interface Comparer { compareTo(x: T, y: U): U; } diff --git a/tests/baselines/reference/implicitAnyGenerics.js b/tests/baselines/reference/implicitAnyGenerics.js index 07478cf0011..172d6c4da3a 100644 --- a/tests/baselines/reference/implicitAnyGenerics.js +++ b/tests/baselines/reference/implicitAnyGenerics.js @@ -1,5 +1,4 @@ //// [implicitAnyGenerics.ts] - class C { x: T; } diff --git a/tests/baselines/reference/implicitAnyGenerics.symbols b/tests/baselines/reference/implicitAnyGenerics.symbols index 22718f1b9d4..9e0ef397270 100644 --- a/tests/baselines/reference/implicitAnyGenerics.symbols +++ b/tests/baselines/reference/implicitAnyGenerics.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/implicitAnyGenerics.ts === - class C { >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 1, 8)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 0, 8)) x: T; ->x : Symbol(C.x, Decl(implicitAnyGenerics.ts, 1, 12)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 1, 8)) +>x : Symbol(C.x, Decl(implicitAnyGenerics.ts, 0, 12)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 0, 8)) } var c = new C(); ->c : Symbol(c, Decl(implicitAnyGenerics.ts, 5, 3)) +>c : Symbol(c, Decl(implicitAnyGenerics.ts, 4, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) var c2 = new C(); ->c2 : Symbol(c2, Decl(implicitAnyGenerics.ts, 6, 3)) +>c2 : Symbol(c2, Decl(implicitAnyGenerics.ts, 5, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) var c3 = new C(); ->c3 : Symbol(c3, Decl(implicitAnyGenerics.ts, 7, 3)) +>c3 : Symbol(c3, Decl(implicitAnyGenerics.ts, 6, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) var c4: C = new C(); ->c4 : Symbol(c4, Decl(implicitAnyGenerics.ts, 8, 3)) +>c4 : Symbol(c4, Decl(implicitAnyGenerics.ts, 7, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) class D { ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 10, 8)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 9, 8)) constructor(x: T) { } ->x : Symbol(x, Decl(implicitAnyGenerics.ts, 11, 16)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 10, 8)) +>x : Symbol(x, Decl(implicitAnyGenerics.ts, 10, 16)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 9, 8)) } var d = new D(null); ->d : Symbol(d, Decl(implicitAnyGenerics.ts, 14, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d : Symbol(d, Decl(implicitAnyGenerics.ts, 13, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d2 = new D(1); ->d2 : Symbol(d2, Decl(implicitAnyGenerics.ts, 15, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d2 : Symbol(d2, Decl(implicitAnyGenerics.ts, 14, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d3 = new D(1); ->d3 : Symbol(d3, Decl(implicitAnyGenerics.ts, 16, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d3 : Symbol(d3, Decl(implicitAnyGenerics.ts, 15, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d4 = new D(1); ->d4 : Symbol(d4, Decl(implicitAnyGenerics.ts, 17, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d4 : Symbol(d4, Decl(implicitAnyGenerics.ts, 16, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d5: D = new D(null); ->d5 : Symbol(d5, Decl(implicitAnyGenerics.ts, 18, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d5 : Symbol(d5, Decl(implicitAnyGenerics.ts, 17, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) function foo(): T { return null; }; ->foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 18, 29)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 20, 13)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 20, 13)) +>foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 17, 29)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 19, 13)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 19, 13)) foo() ->foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 18, 29)) +>foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 17, 29)) foo(); ->foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 18, 29)) +>foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 17, 29)) diff --git a/tests/baselines/reference/implicitAnyGenerics.types b/tests/baselines/reference/implicitAnyGenerics.types index 2d43ecbbdbe..1202c73c51a 100644 --- a/tests/baselines/reference/implicitAnyGenerics.types +++ b/tests/baselines/reference/implicitAnyGenerics.types @@ -1,5 +1,4 @@ === tests/cases/compiler/implicitAnyGenerics.ts === - class C { >C : C >T : T diff --git a/tests/baselines/reference/implicitConstParameters.errors.txt b/tests/baselines/reference/implicitConstParameters.errors.txt index 95ff60d71f8..101f1d35dd1 100644 --- a/tests/baselines/reference/implicitConstParameters.errors.txt +++ b/tests/baselines/reference/implicitConstParameters.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/implicitConstParameters.ts(39,27): error TS2532: Object is possibly 'undefined'. -tests/cases/compiler/implicitConstParameters.ts(45,27): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/implicitConstParameters.ts(38,27): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/implicitConstParameters.ts(44,27): error TS2532: Object is possibly 'undefined'. ==== tests/cases/compiler/implicitConstParameters.ts (2 errors) ==== - function doSomething(cb: () => void) { cb(); } diff --git a/tests/baselines/reference/implicitConstParameters.js b/tests/baselines/reference/implicitConstParameters.js index a5faf5b1253..29b23eda493 100644 --- a/tests/baselines/reference/implicitConstParameters.js +++ b/tests/baselines/reference/implicitConstParameters.js @@ -1,5 +1,4 @@ //// [implicitConstParameters.ts] - function doSomething(cb: () => void) { cb(); } diff --git a/tests/baselines/reference/importHelpersInAmbientContext.js b/tests/baselines/reference/importHelpersInAmbientContext.js index d91daa19a90..c1c00705951 100644 --- a/tests/baselines/reference/importHelpersInAmbientContext.js +++ b/tests/baselines/reference/importHelpersInAmbientContext.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/importHelpersInAmbientContext.ts] //// //// [a.d.ts] - export { }; // Extends diff --git a/tests/baselines/reference/importHelpersInAmbientContext.symbols b/tests/baselines/reference/importHelpersInAmbientContext.symbols index 7da1ea95042..172eea3037f 100644 --- a/tests/baselines/reference/importHelpersInAmbientContext.symbols +++ b/tests/baselines/reference/importHelpersInAmbientContext.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/a.d.ts === - export { }; // Extends declare class C { } ->C : Symbol(C, Decl(a.d.ts, 1, 11)) +>C : Symbol(C, Decl(a.d.ts, 0, 11)) declare class D extends C { } ->D : Symbol(D, Decl(a.d.ts, 4, 19)) ->C : Symbol(C, Decl(a.d.ts, 1, 11)) +>D : Symbol(D, Decl(a.d.ts, 3, 19)) +>C : Symbol(C, Decl(a.d.ts, 0, 11)) // Destructuring interface I { ->I : Symbol(I, Decl(a.d.ts, 5, 29)) +>I : Symbol(I, Decl(a.d.ts, 4, 29)) ({descendants, read}?: { ->descendants : Symbol(descendants, Decl(a.d.ts, 9, 6)) ->read : Symbol(read, Decl(a.d.ts, 9, 18)) +>descendants : Symbol(descendants, Decl(a.d.ts, 8, 6)) +>read : Symbol(read, Decl(a.d.ts, 8, 18)) descendants?: boolean; ->descendants : Symbol(descendants, Decl(a.d.ts, 9, 28)) +>descendants : Symbol(descendants, Decl(a.d.ts, 8, 28)) read?: any; ->read : Symbol(read, Decl(a.d.ts, 10, 30)) +>read : Symbol(read, Decl(a.d.ts, 9, 30)) }): any; } @@ -30,16 +29,16 @@ interface I { // Object Rest interface Foo { ->Foo : Symbol(Foo, Decl(a.d.ts, 13, 1)) +>Foo : Symbol(Foo, Decl(a.d.ts, 12, 1)) a: number; b: string; ->a : Symbol(Foo.a, Decl(a.d.ts, 17, 15)) ->b : Symbol(Foo.b, Decl(a.d.ts, 18, 14)) +>a : Symbol(Foo.a, Decl(a.d.ts, 16, 15)) +>b : Symbol(Foo.b, Decl(a.d.ts, 17, 14)) } export var { a, ...x } : Foo; ->a : Symbol(a, Decl(a.d.ts, 20, 12)) ->x : Symbol(x, Decl(a.d.ts, 20, 15)) ->Foo : Symbol(Foo, Decl(a.d.ts, 13, 1)) +>a : Symbol(a, Decl(a.d.ts, 19, 12)) +>x : Symbol(x, Decl(a.d.ts, 19, 15)) +>Foo : Symbol(Foo, Decl(a.d.ts, 12, 1)) === tests/cases/compiler/b.ts === export {}; diff --git a/tests/baselines/reference/importHelpersInAmbientContext.types b/tests/baselines/reference/importHelpersInAmbientContext.types index 5f3102b68f5..5f01f5b1617 100644 --- a/tests/baselines/reference/importHelpersInAmbientContext.types +++ b/tests/baselines/reference/importHelpersInAmbientContext.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - export { }; // Extends diff --git a/tests/baselines/reference/importShadowsGlobalName.js b/tests/baselines/reference/importShadowsGlobalName.js index 94be0dfd5a0..64631ce5427 100644 --- a/tests/baselines/reference/importShadowsGlobalName.js +++ b/tests/baselines/reference/importShadowsGlobalName.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/importShadowsGlobalName.ts] //// //// [Foo.ts] - class Foo {} export = Foo; diff --git a/tests/baselines/reference/importShadowsGlobalName.symbols b/tests/baselines/reference/importShadowsGlobalName.symbols index f308572737b..8f99aa25adf 100644 --- a/tests/baselines/reference/importShadowsGlobalName.symbols +++ b/tests/baselines/reference/importShadowsGlobalName.symbols @@ -10,7 +10,6 @@ export = Bar; >Bar : Symbol(Bar, Decl(Bar.ts, 0, 30)) === tests/cases/compiler/Foo.ts === - class Foo {} >Foo : Symbol(Foo, Decl(Foo.ts, 0, 0)) diff --git a/tests/baselines/reference/importShadowsGlobalName.types b/tests/baselines/reference/importShadowsGlobalName.types index a1f1106f1b8..9c8e8c99694 100644 --- a/tests/baselines/reference/importShadowsGlobalName.types +++ b/tests/baselines/reference/importShadowsGlobalName.types @@ -10,7 +10,6 @@ export = Bar; >Bar : Bar === tests/cases/compiler/Foo.ts === - class Foo {} >Foo : Foo diff --git a/tests/baselines/reference/importWithTrailingSlash.js b/tests/baselines/reference/importWithTrailingSlash.js index 9450fc5d7b2..9df01dcee66 100644 --- a/tests/baselines/reference/importWithTrailingSlash.js +++ b/tests/baselines/reference/importWithTrailingSlash.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/importWithTrailingSlash.ts] //// //// [a.ts] - export default { a: 0 }; //// [index.ts] diff --git a/tests/baselines/reference/importWithTrailingSlash.symbols b/tests/baselines/reference/importWithTrailingSlash.symbols index 4a9f8b41569..c6c49464380 100644 --- a/tests/baselines/reference/importWithTrailingSlash.symbols +++ b/tests/baselines/reference/importWithTrailingSlash.symbols @@ -1,7 +1,6 @@ === /a.ts === - export default { a: 0 }; ->a : Symbol(a, Decl(a.ts, 1, 16)) +>a : Symbol(a, Decl(a.ts, 0, 16)) === /a/index.ts === export default { aIndex: 0 }; @@ -15,9 +14,9 @@ import aIndex from "./"; >aIndex : Symbol(aIndex, Decl(test.ts, 1, 6)) a.a; ->a.a : Symbol(a, Decl(a.ts, 1, 16)) +>a.a : Symbol(a, Decl(a.ts, 0, 16)) >a : Symbol(a, Decl(test.ts, 0, 6)) ->a : Symbol(a, Decl(a.ts, 1, 16)) +>a : Symbol(a, Decl(a.ts, 0, 16)) aIndex.aIndex; >aIndex.aIndex : Symbol(aIndex, Decl(index.ts, 0, 16)) @@ -32,9 +31,9 @@ import aIndex from "../"; >aIndex : Symbol(aIndex, Decl(test.ts, 1, 6)) a.a; ->a.a : Symbol(a, Decl(a.ts, 1, 16)) +>a.a : Symbol(a, Decl(a.ts, 0, 16)) >a : Symbol(a, Decl(test.ts, 0, 6)) ->a : Symbol(a, Decl(a.ts, 1, 16)) +>a : Symbol(a, Decl(a.ts, 0, 16)) aIndex.aIndex; >aIndex.aIndex : Symbol(aIndex, Decl(index.ts, 0, 16)) diff --git a/tests/baselines/reference/importWithTrailingSlash.types b/tests/baselines/reference/importWithTrailingSlash.types index 7429dcdf42e..beec18ea4aa 100644 --- a/tests/baselines/reference/importWithTrailingSlash.types +++ b/tests/baselines/reference/importWithTrailingSlash.types @@ -1,5 +1,4 @@ === /a.ts === - export default { a: 0 }; >{ a: 0 } : { a: number; } >a : number diff --git a/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt b/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt index 780e1d2f1bc..e501cc5d432 100644 --- a/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt +++ b/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt @@ -1,8 +1,7 @@ -/a.ts(2,17): error TS2307: Cannot find module './foo/'. +/a.ts(1,17): error TS2307: Cannot find module './foo/'. ==== /a.ts (1 errors) ==== - import foo from "./foo/"; ~~~~~~~~ !!! error TS2307: Cannot find module './foo/'. diff --git a/tests/baselines/reference/importWithTrailingSlash_noResolve.js b/tests/baselines/reference/importWithTrailingSlash_noResolve.js index 16a4838ba62..20afebedc2b 100644 --- a/tests/baselines/reference/importWithTrailingSlash_noResolve.js +++ b/tests/baselines/reference/importWithTrailingSlash_noResolve.js @@ -1,5 +1,4 @@ //// [a.ts] - import foo from "./foo/"; diff --git a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js index 9b5e518804c..9e99e9c75eb 100644 --- a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js +++ b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js @@ -4,7 +4,6 @@ export class Host { } //// [consumer.ts] - import host = require("host"); var hostVar = host; var v = new hostVar.Host(); diff --git a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols index 0cc6d0aa9a1..7cd5c3fb3b5 100644 --- a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols +++ b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/consumer.ts === - import host = require("host"); >host : Symbol(host, Decl(consumer.ts, 0, 0)) var hostVar = host; ->hostVar : Symbol(hostVar, Decl(consumer.ts, 2, 3)) +>hostVar : Symbol(hostVar, Decl(consumer.ts, 1, 3)) >host : Symbol(host, Decl(consumer.ts, 0, 0)) var v = new hostVar.Host(); ->v : Symbol(v, Decl(consumer.ts, 3, 3)) +>v : Symbol(v, Decl(consumer.ts, 2, 3)) >hostVar.Host : Symbol(host.Host, Decl(host.ts, 0, 0)) ->hostVar : Symbol(hostVar, Decl(consumer.ts, 2, 3)) +>hostVar : Symbol(hostVar, Decl(consumer.ts, 1, 3)) >Host : Symbol(host.Host, Decl(host.ts, 0, 0)) === tests/cases/compiler/host.ts === diff --git a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types index 137b339347a..a7eeda0299d 100644 --- a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types +++ b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/consumer.ts === - import host = require("host"); >host : typeof host diff --git a/tests/baselines/reference/importsImplicitlyReadonly.errors.txt b/tests/baselines/reference/importsImplicitlyReadonly.errors.txt index 43596ffcea3..aad8480a77a 100644 --- a/tests/baselines/reference/importsImplicitlyReadonly.errors.txt +++ b/tests/baselines/reference/importsImplicitlyReadonly.errors.txt @@ -27,7 +27,6 @@ tests/cases/conformance/externalModules/b.ts(9,4): error TS2540: Cannot assign t a3.x = 1; a3.y = 1; ==== tests/cases/conformance/externalModules/a.ts (0 errors) ==== - export var x = 1; var y = 1; export { y }; diff --git a/tests/baselines/reference/importsImplicitlyReadonly.js b/tests/baselines/reference/importsImplicitlyReadonly.js index dd45d4db89c..724b8c14e53 100644 --- a/tests/baselines/reference/importsImplicitlyReadonly.js +++ b/tests/baselines/reference/importsImplicitlyReadonly.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/externalModules/importsImplicitlyReadonly.ts] //// //// [a.ts] - export var x = 1; var y = 1; export { y }; diff --git a/tests/baselines/reference/importsInAmbientModules1.js b/tests/baselines/reference/importsInAmbientModules1.js index 4c888f2dfe5..da5dcce74f2 100644 --- a/tests/baselines/reference/importsInAmbientModules1.js +++ b/tests/baselines/reference/importsInAmbientModules1.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/importsInAmbientModules1.ts] //// //// [external.d.ts] - export var x: number //// [main.ts] - declare module "M" { import {x} from "external" } diff --git a/tests/baselines/reference/importsInAmbientModules1.symbols b/tests/baselines/reference/importsInAmbientModules1.symbols index d220ba2bf45..4622747ecee 100644 --- a/tests/baselines/reference/importsInAmbientModules1.symbols +++ b/tests/baselines/reference/importsInAmbientModules1.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export var x: number ->x : Symbol(x, Decl(external.d.ts, 1, 10)) +>x : Symbol(x, Decl(external.d.ts, 0, 10)) === tests/cases/compiler/main.ts === - declare module "M" { import {x} from "external" ->x : Symbol(x, Decl(main.ts, 2, 12)) +>x : Symbol(x, Decl(main.ts, 1, 12)) } diff --git a/tests/baselines/reference/importsInAmbientModules1.types b/tests/baselines/reference/importsInAmbientModules1.types index 634de9f1f0f..1d3aa843c9c 100644 --- a/tests/baselines/reference/importsInAmbientModules1.types +++ b/tests/baselines/reference/importsInAmbientModules1.types @@ -1,10 +1,8 @@ === tests/cases/compiler/external.d.ts === - export var x: number >x : number === tests/cases/compiler/main.ts === - declare module "M" { import {x} from "external" >x : number diff --git a/tests/baselines/reference/importsInAmbientModules2.js b/tests/baselines/reference/importsInAmbientModules2.js index 84d5dd84f10..4f1a9d54e37 100644 --- a/tests/baselines/reference/importsInAmbientModules2.js +++ b/tests/baselines/reference/importsInAmbientModules2.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/importsInAmbientModules2.ts] //// //// [external.d.ts] - export default class C {} //// [main.ts] - declare module "M" { import C from "external" } diff --git a/tests/baselines/reference/importsInAmbientModules2.symbols b/tests/baselines/reference/importsInAmbientModules2.symbols index 02333798e8b..68d5bb210aa 100644 --- a/tests/baselines/reference/importsInAmbientModules2.symbols +++ b/tests/baselines/reference/importsInAmbientModules2.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : Symbol(C, Decl(external.d.ts, 0, 0)) === tests/cases/compiler/main.ts === - declare module "M" { import C from "external" ->C : Symbol(C, Decl(main.ts, 2, 10)) +>C : Symbol(C, Decl(main.ts, 1, 10)) } diff --git a/tests/baselines/reference/importsInAmbientModules2.types b/tests/baselines/reference/importsInAmbientModules2.types index d6c4eddc07c..93dda11f672 100644 --- a/tests/baselines/reference/importsInAmbientModules2.types +++ b/tests/baselines/reference/importsInAmbientModules2.types @@ -1,10 +1,8 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : C === tests/cases/compiler/main.ts === - declare module "M" { import C from "external" >C : typeof C diff --git a/tests/baselines/reference/importsInAmbientModules3.js b/tests/baselines/reference/importsInAmbientModules3.js index 2a8e09b53e1..5539b5e8397 100644 --- a/tests/baselines/reference/importsInAmbientModules3.js +++ b/tests/baselines/reference/importsInAmbientModules3.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/importsInAmbientModules3.ts] //// //// [external.d.ts] - export default class C {} //// [main.ts] - declare module "M" { import C = require("external"); } diff --git a/tests/baselines/reference/importsInAmbientModules3.symbols b/tests/baselines/reference/importsInAmbientModules3.symbols index 15b2c7173dc..b75ba644a05 100644 --- a/tests/baselines/reference/importsInAmbientModules3.symbols +++ b/tests/baselines/reference/importsInAmbientModules3.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/main.ts === - declare module "M" { import C = require("external"); ->C : Symbol(C, Decl(main.ts, 1, 20)) +>C : Symbol(C, Decl(main.ts, 0, 20)) } === tests/cases/compiler/external.d.ts === - export default class C {} >C : Symbol(C, Decl(external.d.ts, 0, 0)) diff --git a/tests/baselines/reference/importsInAmbientModules3.types b/tests/baselines/reference/importsInAmbientModules3.types index 6c613687b08..a9b19b19fbc 100644 --- a/tests/baselines/reference/importsInAmbientModules3.types +++ b/tests/baselines/reference/importsInAmbientModules3.types @@ -1,11 +1,9 @@ === tests/cases/compiler/main.ts === - declare module "M" { import C = require("external"); >C : typeof C } === tests/cases/compiler/external.d.ts === - export default class C {} >C : C diff --git a/tests/baselines/reference/incompatibleGenericTypes.errors.txt b/tests/baselines/reference/incompatibleGenericTypes.errors.txt index e5dc6ed5b3c..119d3b41f3d 100644 --- a/tests/baselines/reference/incompatibleGenericTypes.errors.txt +++ b/tests/baselines/reference/incompatibleGenericTypes.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/incompatibleGenericTypes.ts(10,5): error TS2322: Type 'I1' is not assignable to type 'I1'. +tests/cases/compiler/incompatibleGenericTypes.ts(9,5): error TS2322: Type 'I1' is not assignable to type 'I1'. Type 'boolean' is not assignable to type 'number'. ==== tests/cases/compiler/incompatibleGenericTypes.ts (1 errors) ==== - interface I1 { m1(callback: (p: T) => U): I1; diff --git a/tests/baselines/reference/incompatibleGenericTypes.js b/tests/baselines/reference/incompatibleGenericTypes.js index 21a2dbc5e41..633007497fa 100644 --- a/tests/baselines/reference/incompatibleGenericTypes.js +++ b/tests/baselines/reference/incompatibleGenericTypes.js @@ -1,5 +1,4 @@ //// [incompatibleGenericTypes.ts] - interface I1 { m1(callback: (p: T) => U): I1; diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js index 018726f5549..2f5eea63a8a 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js +++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js @@ -1,5 +1,4 @@ //// [inferentialTypingWithFunctionTypeSyntacticScenarios.ts] - declare function map(array: T, func: (x: T) => U): U; declare function identity(y: V): V; var s: string; diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols index 1ad418cb599..a9571bc8a38 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols +++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols @@ -1,95 +1,94 @@ === tests/cases/compiler/inferentialTypingWithFunctionTypeSyntacticScenarios.ts === - declare function map(array: T, func: (x: T) => U): U; >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 21)) ->U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 23)) ->array : Symbol(array, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 27)) ->T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 21)) ->func : Symbol(func, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 36)) ->x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 44)) ->T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 21)) ->U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 23)) ->U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 23)) +>T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 21)) +>U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 23)) +>array : Symbol(array, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 27)) +>T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 21)) +>func : Symbol(func, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 36)) +>x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 44)) +>T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 21)) +>U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 23)) +>U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 23)) declare function identity(y: V): V; ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) ->V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 26)) ->y : Symbol(y, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 29)) ->V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 26)) ->V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 26)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) +>V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 26)) +>y : Symbol(y, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 29)) +>V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 26)) +>V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 26)) var s: string; ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) // dotted name var dottedIdentity = { x: identity }; ->dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 3)) ->x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3)) +>x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) s = map("", dottedIdentity.x); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->dottedIdentity.x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) ->dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 3)) ->x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) +>dottedIdentity.x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) +>dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3)) +>x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) // index expression s = map("", dottedIdentity['x']); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 3)) ->'x' : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) +>dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3)) +>'x' : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) // function call s = map("", (() => identity)()); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // construct interface IdentityConstructor { ->IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 13, 32)) +>IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 12, 32)) new (): typeof identity; ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) } var ic: IdentityConstructor; ->ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 19, 3)) ->IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 13, 32)) +>ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 18, 3)) +>IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 12, 32)) s = map("", new ic()); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 19, 3)) +>ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 18, 3)) // assignment var t; ->t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 23, 3)) +>t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 22, 3)) s = map("", t = identity); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 23, 3)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 22, 3)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // type assertion s = map("", identity); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // parenthesized expression s = map("", (identity)); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // comma s = map("", ("", identity)); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types index 258b4cbfa46..cb7904b8060 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types +++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types @@ -1,5 +1,4 @@ === tests/cases/compiler/inferentialTypingWithFunctionTypeSyntacticScenarios.ts === - declare function map(array: T, func: (x: T) => U): U; >map : (array: T, func: (x: T) => U) => U >T : T diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js index 2993a331fee..ba528d4c133 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js @@ -1,5 +1,4 @@ //// [inferredFunctionReturnTypeIsEmptyType.ts] - function foo() { if (true) { return 42; diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols index 059a992c3f3..8fdfe5233e7 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts === - function foo() { >foo : Symbol(foo, Decl(inferredFunctionReturnTypeIsEmptyType.ts, 0, 0)) diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types index 3775ffd2faa..ba643dc3d62 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts === - function foo() { >foo : () => 42 | "42" diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt index 787b95f2297..08aab5b1158 100644 --- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt +++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(6,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(5,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts (2 errors) ==== - class a { static get x(): () => string { ~ diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js index 79d2e88b646..3c19e3c5f67 100644 --- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js +++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js @@ -1,5 +1,4 @@ //// [inheritanceStaticPropertyOverridingAccessor.ts] - class a { static get x(): () => string { return null;; diff --git a/tests/baselines/reference/inheritedGenericCallSignature.js b/tests/baselines/reference/inheritedGenericCallSignature.js index 2ee6e2149a9..2f28498fc8c 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.js +++ b/tests/baselines/reference/inheritedGenericCallSignature.js @@ -1,5 +1,4 @@ //// [inheritedGenericCallSignature.ts] - interface I1 { (a: T): T; diff --git a/tests/baselines/reference/inheritedGenericCallSignature.symbols b/tests/baselines/reference/inheritedGenericCallSignature.symbols index 57469f4dad8..715393e6a31 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.symbols +++ b/tests/baselines/reference/inheritedGenericCallSignature.symbols @@ -1,50 +1,49 @@ === tests/cases/compiler/inheritedGenericCallSignature.ts === - interface I1 { >I1 : Symbol(I1, Decl(inheritedGenericCallSignature.ts, 0, 0)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 1, 13)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 0, 13)) (a: T): T; ->a : Symbol(a, Decl(inheritedGenericCallSignature.ts, 3, 5)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 1, 13)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 1, 13)) +>a : Symbol(a, Decl(inheritedGenericCallSignature.ts, 2, 5)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 0, 13)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 0, 13)) } interface Object {} ->Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(inheritedGenericCallSignature.ts, 5, 1)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(inheritedGenericCallSignature.ts, 4, 1)) interface I2 extends I1 { ->I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 8, 19)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 12, 13)) +>I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 7, 19)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 11, 13)) >I1 : Symbol(I1, Decl(inheritedGenericCallSignature.ts, 0, 0)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 12, 13)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 11, 13)) b: T; ->b : Symbol(I2.b, Decl(inheritedGenericCallSignature.ts, 12, 33)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 12, 13)) +>b : Symbol(I2.b, Decl(inheritedGenericCallSignature.ts, 11, 33)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 11, 13)) } var x: I2; ->x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 20, 3)) ->I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 8, 19)) +>x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 19, 3)) +>I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 7, 19)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var y = x(undefined); ->y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 24, 3)) ->x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 20, 3)) +>y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 23, 3)) +>x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 19, 3)) >undefined : Symbol(undefined) y.length; // should not error >y.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 24, 3)) +>y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 23, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inheritedGenericCallSignature.types b/tests/baselines/reference/inheritedGenericCallSignature.types index 4382320862b..ca881df6c5d 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.types +++ b/tests/baselines/reference/inheritedGenericCallSignature.types @@ -1,5 +1,4 @@ === tests/cases/compiler/inheritedGenericCallSignature.ts === - interface I1 { >I1 : I1 >T : T diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.js b/tests/baselines/reference/initializePropertiesWithRenamedLet.js index 4abe488aa08..d6c53b7d525 100644 --- a/tests/baselines/reference/initializePropertiesWithRenamedLet.js +++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.js @@ -1,5 +1,4 @@ //// [initializePropertiesWithRenamedLet.ts] - var x0; if (true) { let x0; diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols index f16d8cfc9e0..02abf8c80e0 100644 --- a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols +++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols @@ -1,46 +1,45 @@ === tests/cases/compiler/initializePropertiesWithRenamedLet.ts === - var x0; ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 1, 3)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 0, 3)) if (true) { let x0; ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 7)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 2, 7)) var obj1 = { x0: x0 }; ->obj1 : Symbol(obj1, Decl(initializePropertiesWithRenamedLet.ts, 4, 7)) ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 4, 16)) ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 7)) +>obj1 : Symbol(obj1, Decl(initializePropertiesWithRenamedLet.ts, 3, 7)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 16)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 2, 7)) var obj2 = { x0 }; ->obj2 : Symbol(obj2, Decl(initializePropertiesWithRenamedLet.ts, 5, 7)) ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 5, 16)) +>obj2 : Symbol(obj2, Decl(initializePropertiesWithRenamedLet.ts, 4, 7)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 4, 16)) } var x, y, z; ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 8, 3)) ->y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 8, 6)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 8, 9)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 7, 3)) +>y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 7, 6)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 7, 9)) if (true) { let { x: x } = { x: 0 }; ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 20)) ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 9)) ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 20)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 9, 20)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 9, 9)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 9, 20)) let { y } = { y: 0 }; ->y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 9)) ->y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 17)) +>y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 10, 9)) +>y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 10, 17)) let z; ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 11, 7)) ({ z: z } = { z: 0 }); ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 6)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 17)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 6)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 11, 7)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 17)) ({ z } = { z: 0 }); ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 6)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 14)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 6)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 14)) } diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.types b/tests/baselines/reference/initializePropertiesWithRenamedLet.types index 65ea68059a7..cfcf1957125 100644 --- a/tests/baselines/reference/initializePropertiesWithRenamedLet.types +++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.types @@ -1,5 +1,4 @@ === tests/cases/compiler/initializePropertiesWithRenamedLet.ts === - var x0; >x0 : any diff --git a/tests/baselines/reference/initializersInDeclarations.errors.txt b/tests/baselines/reference/initializersInDeclarations.errors.txt index c8b307cb21c..34a7b67e5d5 100644 --- a/tests/baselines/reference/initializersInDeclarations.errors.txt +++ b/tests/baselines/reference/initializersInDeclarations.errors.txt @@ -1,14 +1,13 @@ -tests/cases/conformance/externalModules/file1.d.ts(5,9): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(6,16): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(7,16): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(4,9): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(5,16): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(6,16): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(11,15): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/externalModules/file1.d.ts(12,15): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(13,15): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(16,2): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(18,16): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(15,2): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(17,16): error TS1039: Initializers are not allowed in ambient contexts. ==== tests/cases/conformance/externalModules/file1.d.ts (7 errors) ==== - // Errors: Initializers & statements in declaration file declare class Foo { diff --git a/tests/baselines/reference/inlineSourceMap.errors.txt b/tests/baselines/reference/inlineSourceMap.errors.txt index 8d92d6a161d..69ea738f6bd 100644 --- a/tests/baselines/reference/inlineSourceMap.errors.txt +++ b/tests/baselines/reference/inlineSourceMap.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/inlineSourceMap.ts(3,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/inlineSourceMap.ts(2,1): error TS2304: Cannot find name 'console'. ==== tests/cases/compiler/inlineSourceMap.ts (1 errors) ==== - var x = 0; console.log(x); ~~~~~~~ diff --git a/tests/baselines/reference/inlineSourceMap.js b/tests/baselines/reference/inlineSourceMap.js index 94ad43d4487..2bc68adc516 100644 --- a/tests/baselines/reference/inlineSourceMap.js +++ b/tests/baselines/reference/inlineSourceMap.js @@ -1,9 +1,8 @@ //// [inlineSourceMap.ts] - var x = 0; console.log(x); //// [inlineSourceMap.js] var x = 0; console.log(x); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSourceMap.sourcemap.txt b/tests/baselines/reference/inlineSourceMap.sourcemap.txt index 35bee4f1d4a..7967c04e905 100644 --- a/tests/baselines/reference/inlineSourceMap.sourcemap.txt +++ b/tests/baselines/reference/inlineSourceMap.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: inlineSourceMap.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== sourceRoot: sources: inlineSourceMap.ts =================================================================== @@ -16,19 +16,18 @@ sourceFile:inlineSourceMap.ts 5 > ^ 6 > ^ 7 > ^^^^^^-> -1 > - > +1 > 2 >var 3 > x 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>console.log(x); 1-> @@ -49,13 +48,13 @@ sourceFile:inlineSourceMap.ts 6 > x 7 > ) 8 > ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -3 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) -4 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -5 >Emitted(2, 13) Source(3, 13) + SourceIndex(0) -6 >Emitted(2, 14) Source(3, 14) + SourceIndex(0) -7 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -8 >Emitted(2, 16) Source(3, 16) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +3 >Emitted(2, 9) Source(2, 9) + SourceIndex(0) +4 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +5 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +6 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) +7 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +8 >Emitted(2, 16) Source(2, 16) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSourceMap2.errors.txt b/tests/baselines/reference/inlineSourceMap2.errors.txt index 26db1415593..ee60b349348 100644 --- a/tests/baselines/reference/inlineSourceMap2.errors.txt +++ b/tests/baselines/reference/inlineSourceMap2.errors.txt @@ -1,12 +1,11 @@ error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'. error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'. -tests/cases/compiler/inlineSourceMap2.ts(5,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/inlineSourceMap2.ts(4,1): error TS2304: Cannot find name 'console'. !!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'. !!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'. ==== tests/cases/compiler/inlineSourceMap2.ts (1 errors) ==== - // configuration errors var x = 0; diff --git a/tests/baselines/reference/inlineSourceMap2.js b/tests/baselines/reference/inlineSourceMap2.js index 9cf27863346..ce39cfbbf6b 100644 --- a/tests/baselines/reference/inlineSourceMap2.js +++ b/tests/baselines/reference/inlineSourceMap2.js @@ -1,5 +1,4 @@ //// [inlineSourceMap2.ts] - // configuration errors var x = 0; @@ -9,4 +8,4 @@ console.log(x); // configuration errors var x = 0; console.log(x); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSourceMap2.sourcemap.txt b/tests/baselines/reference/inlineSourceMap2.sourcemap.txt index e292a9b96b2..5407acb05fd 100644 --- a/tests/baselines/reference/inlineSourceMap2.sourcemap.txt +++ b/tests/baselines/reference/inlineSourceMap2.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: outfile.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== sourceRoot: file:///folder/ sources: inlineSourceMap2.ts =================================================================== @@ -11,11 +11,10 @@ sourceFile:inlineSourceMap2.ts >>>// configuration errors 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^ -1 > - > +1 > 2 >// configuration errors -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 24) Source(2, 24) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 24) Source(1, 24) + SourceIndex(0) --- >>>var x = 0; 1 > @@ -33,12 +32,12 @@ sourceFile:inlineSourceMap2.ts 4 > = 5 > 0 6 > ; -1 >Emitted(2, 1) Source(4, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(4, 5) + SourceIndex(0) -3 >Emitted(2, 6) Source(4, 6) + SourceIndex(0) -4 >Emitted(2, 9) Source(4, 9) + SourceIndex(0) -5 >Emitted(2, 10) Source(4, 10) + SourceIndex(0) -6 >Emitted(2, 11) Source(4, 11) + SourceIndex(0) +1 >Emitted(2, 1) Source(3, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) +3 >Emitted(2, 6) Source(3, 6) + SourceIndex(0) +4 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) +5 >Emitted(2, 10) Source(3, 10) + SourceIndex(0) +6 >Emitted(2, 11) Source(3, 11) + SourceIndex(0) --- >>>console.log(x); 1-> @@ -59,13 +58,13 @@ sourceFile:inlineSourceMap2.ts 6 > x 7 > ) 8 > ; -1->Emitted(3, 1) Source(5, 1) + SourceIndex(0) -2 >Emitted(3, 8) Source(5, 8) + SourceIndex(0) -3 >Emitted(3, 9) Source(5, 9) + SourceIndex(0) -4 >Emitted(3, 12) Source(5, 12) + SourceIndex(0) -5 >Emitted(3, 13) Source(5, 13) + SourceIndex(0) -6 >Emitted(3, 14) Source(5, 14) + SourceIndex(0) -7 >Emitted(3, 15) Source(5, 15) + SourceIndex(0) -8 >Emitted(3, 16) Source(5, 16) + SourceIndex(0) +1->Emitted(3, 1) Source(4, 1) + SourceIndex(0) +2 >Emitted(3, 8) Source(4, 8) + SourceIndex(0) +3 >Emitted(3, 9) Source(4, 9) + SourceIndex(0) +4 >Emitted(3, 12) Source(4, 12) + SourceIndex(0) +5 >Emitted(3, 13) Source(4, 13) + SourceIndex(0) +6 >Emitted(3, 14) Source(4, 14) + SourceIndex(0) +7 >Emitted(3, 15) Source(4, 15) + SourceIndex(0) +8 >Emitted(3, 16) Source(4, 16) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSources.errors.txt b/tests/baselines/reference/inlineSources.errors.txt index 1c86dcf4d99..ff72c35b867 100644 --- a/tests/baselines/reference/inlineSources.errors.txt +++ b/tests/baselines/reference/inlineSources.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.ts(3,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/a.ts(2,1): error TS2304: Cannot find name 'console'. tests/cases/compiler/b.ts(2,1): error TS2304: Cannot find name 'console'. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 0; console.log(a); ~~~~~~~ diff --git a/tests/baselines/reference/inlineSources.js b/tests/baselines/reference/inlineSources.js index c700af7e4c6..8ac6bf43bee 100644 --- a/tests/baselines/reference/inlineSources.js +++ b/tests/baselines/reference/inlineSources.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/inlineSources.ts] //// //// [a.ts] - var a = 0; console.log(a); diff --git a/tests/baselines/reference/inlineSources.js.map b/tests/baselines/reference/inlineSources.js.map index 7e09d95a35c..8ccdb8c32f7 100644 --- a/tests/baselines/reference/inlineSources.js.map +++ b/tests/baselines/reference/inlineSources.js.map @@ -1,2 +1,2 @@ //// [out.js.map] -{"version":3,"file":"out.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;ACFf,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC","sourcesContent":["\nvar a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"]} \ No newline at end of file +{"version":3,"file":"out.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;ACDf,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC","sourcesContent":["var a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"]} \ No newline at end of file diff --git a/tests/baselines/reference/inlineSources.sourcemap.txt b/tests/baselines/reference/inlineSources.sourcemap.txt index 47d762f044e..a6a55d0cb35 100644 --- a/tests/baselines/reference/inlineSources.sourcemap.txt +++ b/tests/baselines/reference/inlineSources.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: out.js mapUrl: out.js.map sourceRoot: sources: tests/cases/compiler/a.ts,tests/cases/compiler/b.ts -sourcesContent: ["\nvar a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] +sourcesContent: ["var a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] =================================================================== ------------------------------------------------------------------- emittedFile:out.js @@ -17,19 +17,18 @@ sourceFile:tests/cases/compiler/a.ts 5 > ^ 6 > ^ 7 > ^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>console.log(a); 1-> @@ -49,14 +48,14 @@ sourceFile:tests/cases/compiler/a.ts 6 > a 7 > ) 8 > ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -3 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) -4 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -5 >Emitted(2, 13) Source(3, 13) + SourceIndex(0) -6 >Emitted(2, 14) Source(3, 14) + SourceIndex(0) -7 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -8 >Emitted(2, 16) Source(3, 16) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +3 >Emitted(2, 9) Source(2, 9) + SourceIndex(0) +4 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +5 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +6 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) +7 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +8 >Emitted(2, 16) Source(2, 16) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:out.js diff --git a/tests/baselines/reference/inlineSources2.errors.txt b/tests/baselines/reference/inlineSources2.errors.txt index 1c86dcf4d99..ff72c35b867 100644 --- a/tests/baselines/reference/inlineSources2.errors.txt +++ b/tests/baselines/reference/inlineSources2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.ts(3,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/a.ts(2,1): error TS2304: Cannot find name 'console'. tests/cases/compiler/b.ts(2,1): error TS2304: Cannot find name 'console'. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 0; console.log(a); ~~~~~~~ diff --git a/tests/baselines/reference/inlineSources2.js b/tests/baselines/reference/inlineSources2.js index 7f4c82f2ac2..e5909c5769e 100644 --- a/tests/baselines/reference/inlineSources2.js +++ b/tests/baselines/reference/inlineSources2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/inlineSources2.ts] //// //// [a.ts] - var a = 0; console.log(a); @@ -14,4 +13,4 @@ var a = 0; console.log(a); var b = 0; console.log(b); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0ZmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbnZhciBhID0gMDtcbmNvbnNvbGUubG9nKGEpO1xuIiwidmFyIGIgPSAwO1xuY29uc29sZS5sb2coYik7Il19 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0RmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgYSA9IDA7XG5jb25zb2xlLmxvZyhhKTtcbiIsInZhciBiID0gMDtcbmNvbnNvbGUubG9nKGIpOyJdfQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSources2.sourcemap.txt b/tests/baselines/reference/inlineSources2.sourcemap.txt index e09af2f4221..0ce95f4de4d 100644 --- a/tests/baselines/reference/inlineSources2.sourcemap.txt +++ b/tests/baselines/reference/inlineSources2.sourcemap.txt @@ -1,9 +1,9 @@ =================================================================== JsFile: out.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0ZmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbnZhciBhID0gMDtcbmNvbnNvbGUubG9nKGEpO1xuIiwidmFyIGIgPSAwO1xuY29uc29sZS5sb2coYik7Il19 +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0RmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgYSA9IDA7XG5jb25zb2xlLmxvZyhhKTtcbiIsInZhciBiID0gMDtcbmNvbnNvbGUubG9nKGIpOyJdfQ== sourceRoot: sources: tests/cases/compiler/a.ts,tests/cases/compiler/b.ts -sourcesContent: ["\nvar a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] +sourcesContent: ["var a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] =================================================================== ------------------------------------------------------------------- emittedFile:out.js @@ -17,19 +17,18 @@ sourceFile:tests/cases/compiler/a.ts 5 > ^ 6 > ^ 7 > ^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>console.log(a); 1-> @@ -49,14 +48,14 @@ sourceFile:tests/cases/compiler/a.ts 6 > a 7 > ) 8 > ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -3 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) -4 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -5 >Emitted(2, 13) Source(3, 13) + SourceIndex(0) -6 >Emitted(2, 14) Source(3, 14) + SourceIndex(0) -7 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -8 >Emitted(2, 16) Source(3, 16) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +3 >Emitted(2, 9) Source(2, 9) + SourceIndex(0) +4 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +5 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +6 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) +7 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +8 >Emitted(2, 16) Source(2, 16) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:out.js @@ -111,4 +110,4 @@ sourceFile:tests/cases/compiler/b.ts 7 >Emitted(4, 15) Source(2, 15) + SourceIndex(1) 8 >Emitted(4, 16) Source(2, 16) + SourceIndex(1) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0ZmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbnZhciBhID0gMDtcbmNvbnNvbGUubG9nKGEpO1xuIiwidmFyIGIgPSAwO1xuY29uc29sZS5sb2coYik7Il19 \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0RmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgYSA9IDA7XG5jb25zb2xlLmxvZyhhKTtcbiIsInZhciBiID0gMDtcbmNvbnNvbGUubG9nKGIpOyJdfQ== \ No newline at end of file diff --git a/tests/baselines/reference/innerOverloads.js b/tests/baselines/reference/innerOverloads.js index 19e3fa78909..b7616011694 100644 --- a/tests/baselines/reference/innerOverloads.js +++ b/tests/baselines/reference/innerOverloads.js @@ -1,5 +1,4 @@ //// [innerOverloads.ts] - function outer() { function inner(x:number); // should work function inner(x:string); diff --git a/tests/baselines/reference/innerOverloads.symbols b/tests/baselines/reference/innerOverloads.symbols index d87a60b26e8..5d9aaffc8f0 100644 --- a/tests/baselines/reference/innerOverloads.symbols +++ b/tests/baselines/reference/innerOverloads.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/innerOverloads.ts === - function outer() { >outer : Symbol(outer, Decl(innerOverloads.ts, 0, 0)) function inner(x:number); // should work ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) ->x : Symbol(x, Decl(innerOverloads.ts, 2, 19)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) +>x : Symbol(x, Decl(innerOverloads.ts, 1, 19)) function inner(x:string); ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) ->x : Symbol(x, Decl(innerOverloads.ts, 3, 19)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) +>x : Symbol(x, Decl(innerOverloads.ts, 2, 19)) function inner(a:any) { return a; } ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) ->a : Symbol(a, Decl(innerOverloads.ts, 4, 19)) ->a : Symbol(a, Decl(innerOverloads.ts, 4, 19)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) +>a : Symbol(a, Decl(innerOverloads.ts, 3, 19)) +>a : Symbol(a, Decl(innerOverloads.ts, 3, 19)) return inner(0); ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) } var x = outer(); // should work ->x : Symbol(x, Decl(innerOverloads.ts, 9, 3)) +>x : Symbol(x, Decl(innerOverloads.ts, 8, 3)) >outer : Symbol(outer, Decl(innerOverloads.ts, 0, 0)) diff --git a/tests/baselines/reference/innerOverloads.types b/tests/baselines/reference/innerOverloads.types index b15f9e5bf22..0d7168ea4e0 100644 --- a/tests/baselines/reference/innerOverloads.types +++ b/tests/baselines/reference/innerOverloads.types @@ -1,5 +1,4 @@ === tests/cases/compiler/innerOverloads.ts === - function outer() { >outer : () => any diff --git a/tests/baselines/reference/instantiatedTypeAliasDisplay.js b/tests/baselines/reference/instantiatedTypeAliasDisplay.js index 9c2b91b613e..272266e0bea 100644 --- a/tests/baselines/reference/instantiatedTypeAliasDisplay.js +++ b/tests/baselines/reference/instantiatedTypeAliasDisplay.js @@ -1,5 +1,4 @@ //// [instantiatedTypeAliasDisplay.ts] - // Repros from #12066 interface X { diff --git a/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols b/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols index fa8140cfcd7..3c6f7d2b725 100644 --- a/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols +++ b/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols @@ -1,61 +1,60 @@ === tests/cases/compiler/instantiatedTypeAliasDisplay.ts === - // Repros from #12066 interface X { >X : Symbol(X, Decl(instantiatedTypeAliasDisplay.ts, 0, 0)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 3, 12)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 2, 12)) a: A; ->a : Symbol(X.a, Decl(instantiatedTypeAliasDisplay.ts, 3, 16)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 3, 12)) +>a : Symbol(X.a, Decl(instantiatedTypeAliasDisplay.ts, 2, 16)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 2, 12)) } interface Y { ->Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 5, 1)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 6, 12)) +>Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 4, 1)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 5, 12)) b: B; ->b : Symbol(Y.b, Decl(instantiatedTypeAliasDisplay.ts, 6, 16)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 6, 12)) +>b : Symbol(Y.b, Decl(instantiatedTypeAliasDisplay.ts, 5, 16)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 5, 12)) } type Z = X | Y; ->Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 8, 1)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 9, 7)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 9, 9)) +>Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 7, 1)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 8, 7)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 8, 9)) >X : Symbol(X, Decl(instantiatedTypeAliasDisplay.ts, 0, 0)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 9, 7)) ->Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 5, 1)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 9, 9)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 8, 7)) +>Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 4, 1)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 8, 9)) declare function f1(): Z; ->f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 9, 27)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) ->Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 8, 1)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) +>f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 8, 27)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 10, 20)) +>Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 7, 1)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 10, 20)) declare function f2(a: A, b: B, c: C, d: D): Z; ->f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 11, 39)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 12, 20)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 12, 22)) ->C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 12, 25)) ->D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 12, 28)) ->E : Symbol(E, Decl(instantiatedTypeAliasDisplay.ts, 12, 31)) ->a : Symbol(a, Decl(instantiatedTypeAliasDisplay.ts, 12, 35)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 12, 20)) ->b : Symbol(b, Decl(instantiatedTypeAliasDisplay.ts, 12, 40)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 12, 22)) ->c : Symbol(c, Decl(instantiatedTypeAliasDisplay.ts, 12, 46)) ->C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 12, 25)) ->d : Symbol(d, Decl(instantiatedTypeAliasDisplay.ts, 12, 52)) ->D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 12, 28)) ->Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 8, 1)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 12, 20)) +>f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 10, 39)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 11, 22)) +>C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 11, 25)) +>D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 11, 28)) +>E : Symbol(E, Decl(instantiatedTypeAliasDisplay.ts, 11, 31)) +>a : Symbol(a, Decl(instantiatedTypeAliasDisplay.ts, 11, 35)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) +>b : Symbol(b, Decl(instantiatedTypeAliasDisplay.ts, 11, 40)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 11, 22)) +>c : Symbol(c, Decl(instantiatedTypeAliasDisplay.ts, 11, 46)) +>C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 11, 25)) +>d : Symbol(d, Decl(instantiatedTypeAliasDisplay.ts, 11, 52)) +>D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 11, 28)) +>Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 7, 1)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) const x1 = f1(); // Z ->x1 : Symbol(x1, Decl(instantiatedTypeAliasDisplay.ts, 14, 5)) ->f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 9, 27)) +>x1 : Symbol(x1, Decl(instantiatedTypeAliasDisplay.ts, 13, 5)) +>f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 8, 27)) const x2 = f2({}, {}, {}, {}); // Z<{}, string[]> ->x2 : Symbol(x2, Decl(instantiatedTypeAliasDisplay.ts, 15, 5)) ->f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 11, 39)) +>x2 : Symbol(x2, Decl(instantiatedTypeAliasDisplay.ts, 14, 5)) +>f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 10, 39)) diff --git a/tests/baselines/reference/instantiatedTypeAliasDisplay.types b/tests/baselines/reference/instantiatedTypeAliasDisplay.types index 89320e1dba6..44885777e74 100644 --- a/tests/baselines/reference/instantiatedTypeAliasDisplay.types +++ b/tests/baselines/reference/instantiatedTypeAliasDisplay.types @@ -1,5 +1,4 @@ === tests/cases/compiler/instantiatedTypeAliasDisplay.ts === - // Repros from #12066 interface X { diff --git a/tests/baselines/reference/interfaceExtendingClass2.errors.txt b/tests/baselines/reference/interfaceExtendingClass2.errors.txt index 859cb65410e..3b394d4922a 100644 --- a/tests/baselines/reference/interfaceExtendingClass2.errors.txt +++ b/tests/baselines/reference/interfaceExtendingClass2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(12,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,13): error TS1131: Property or signature expected. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(16,5): error TS1128: Declaration or statement expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(11,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(13,13): error TS1131: Property or signature expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,9): error TS1128: Declaration or statement expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,5): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts (4 errors) ==== - class Foo { x: string; y() { } diff --git a/tests/baselines/reference/interfaceExtendingClass2.js b/tests/baselines/reference/interfaceExtendingClass2.js index c04ecf1d1bb..e3ede26b48e 100644 --- a/tests/baselines/reference/interfaceExtendingClass2.js +++ b/tests/baselines/reference/interfaceExtendingClass2.js @@ -1,5 +1,4 @@ //// [interfaceExtendingClass2.ts] - class Foo { x: string; y() { } diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.js b/tests/baselines/reference/interfaceExtendsObjectIntersection.js index a6fb62f5070..678829edeb8 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.js +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.js @@ -1,5 +1,4 @@ //// [interfaceExtendsObjectIntersection.ts] - type T1 = { a: number }; type T2 = T1 & { b: number }; type T3 = () => void; diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols index 16c8c51cf47..2c353036af2 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols @@ -1,230 +1,229 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts === - type T1 = { a: number }; >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 1, 11)) +>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 0, 11)) type T2 = T1 & { b: number }; ->T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 1, 24)) +>T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 0, 24)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 2, 16)) +>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 1, 16)) type T3 = () => void; ->T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 2, 29)) +>T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 1, 29)) type T4 = new () => { a: number }; ->T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 3, 21)) ->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 4, 21)) +>T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 2, 21)) +>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 3, 21)) type T5 = number[]; ->T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 4, 34)) +>T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 3, 34)) type T6 = [string, number]; ->T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 5, 19)) +>T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 4, 19)) type T7 = { [P in 'a' | 'b' | 'c']: string }; ->T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 6, 27)) ->P : Symbol(P, Decl(interfaceExtendsObjectIntersection.ts, 7, 13)) +>T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 5, 27)) +>P : Symbol(P, Decl(interfaceExtendsObjectIntersection.ts, 6, 13)) interface I1 extends T1 { x: string } ->I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 7, 45)) +>I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 6, 45)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I1.x, Decl(interfaceExtendsObjectIntersection.ts, 9, 25)) +>x : Symbol(I1.x, Decl(interfaceExtendsObjectIntersection.ts, 8, 25)) interface I2 extends T2 { x: string } ->I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) ->T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 1, 24)) ->x : Symbol(I2.x, Decl(interfaceExtendsObjectIntersection.ts, 10, 25)) +>I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 8, 37)) +>T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 0, 24)) +>x : Symbol(I2.x, Decl(interfaceExtendsObjectIntersection.ts, 9, 25)) interface I3 extends T3 { x: string } ->I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) ->T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 2, 29)) ->x : Symbol(I3.x, Decl(interfaceExtendsObjectIntersection.ts, 11, 25)) +>I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) +>T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 1, 29)) +>x : Symbol(I3.x, Decl(interfaceExtendsObjectIntersection.ts, 10, 25)) interface I4 extends T4 { x: string } ->I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) ->T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 3, 21)) ->x : Symbol(I4.x, Decl(interfaceExtendsObjectIntersection.ts, 12, 25)) +>I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) +>T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 2, 21)) +>x : Symbol(I4.x, Decl(interfaceExtendsObjectIntersection.ts, 11, 25)) interface I5 extends T5 { x: string } ->I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) ->T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 4, 34)) ->x : Symbol(I5.x, Decl(interfaceExtendsObjectIntersection.ts, 13, 25)) +>I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) +>T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 3, 34)) +>x : Symbol(I5.x, Decl(interfaceExtendsObjectIntersection.ts, 12, 25)) interface I6 extends T6 { x: string } ->I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) ->T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 5, 19)) ->x : Symbol(I6.x, Decl(interfaceExtendsObjectIntersection.ts, 14, 25)) +>I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) +>T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 4, 19)) +>x : Symbol(I6.x, Decl(interfaceExtendsObjectIntersection.ts, 13, 25)) interface I7 extends T7 { x: string } ->I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 14, 37)) ->T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 6, 27)) ->x : Symbol(I7.x, Decl(interfaceExtendsObjectIntersection.ts, 15, 25)) +>I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) +>T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 5, 27)) +>x : Symbol(I7.x, Decl(interfaceExtendsObjectIntersection.ts, 14, 25)) type Constructor = new () => T; ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 17)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 17)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 16, 17)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 16, 17)) declare function Constructor(): Constructor; ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 18, 29)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 18, 29)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 29)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 29)) class C1 extends Constructor() { x: string } ->C1 : Symbol(C1, Decl(interfaceExtendsObjectIntersection.ts, 18, 50)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 7, 45)) ->x : Symbol(C1.x, Decl(interfaceExtendsObjectIntersection.ts, 20, 36)) +>C1 : Symbol(C1, Decl(interfaceExtendsObjectIntersection.ts, 17, 50)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 6, 45)) +>x : Symbol(C1.x, Decl(interfaceExtendsObjectIntersection.ts, 19, 36)) class C2 extends Constructor() { x: string } ->C2 : Symbol(C2, Decl(interfaceExtendsObjectIntersection.ts, 20, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) ->x : Symbol(C2.x, Decl(interfaceExtendsObjectIntersection.ts, 21, 36)) +>C2 : Symbol(C2, Decl(interfaceExtendsObjectIntersection.ts, 19, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 8, 37)) +>x : Symbol(C2.x, Decl(interfaceExtendsObjectIntersection.ts, 20, 36)) class C3 extends Constructor() { x: string } ->C3 : Symbol(C3, Decl(interfaceExtendsObjectIntersection.ts, 21, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) ->x : Symbol(C3.x, Decl(interfaceExtendsObjectIntersection.ts, 22, 36)) +>C3 : Symbol(C3, Decl(interfaceExtendsObjectIntersection.ts, 20, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) +>x : Symbol(C3.x, Decl(interfaceExtendsObjectIntersection.ts, 21, 36)) class C4 extends Constructor() { x: string } ->C4 : Symbol(C4, Decl(interfaceExtendsObjectIntersection.ts, 22, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) ->x : Symbol(C4.x, Decl(interfaceExtendsObjectIntersection.ts, 23, 36)) +>C4 : Symbol(C4, Decl(interfaceExtendsObjectIntersection.ts, 21, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) +>x : Symbol(C4.x, Decl(interfaceExtendsObjectIntersection.ts, 22, 36)) class C5 extends Constructor() { x: string } ->C5 : Symbol(C5, Decl(interfaceExtendsObjectIntersection.ts, 23, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) ->x : Symbol(C5.x, Decl(interfaceExtendsObjectIntersection.ts, 24, 36)) +>C5 : Symbol(C5, Decl(interfaceExtendsObjectIntersection.ts, 22, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) +>x : Symbol(C5.x, Decl(interfaceExtendsObjectIntersection.ts, 23, 36)) class C6 extends Constructor() { x: string } ->C6 : Symbol(C6, Decl(interfaceExtendsObjectIntersection.ts, 24, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) ->x : Symbol(C6.x, Decl(interfaceExtendsObjectIntersection.ts, 25, 36)) +>C6 : Symbol(C6, Decl(interfaceExtendsObjectIntersection.ts, 23, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) +>x : Symbol(C6.x, Decl(interfaceExtendsObjectIntersection.ts, 24, 36)) class C7 extends Constructor() { x: string } ->C7 : Symbol(C7, Decl(interfaceExtendsObjectIntersection.ts, 25, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 14, 37)) ->x : Symbol(C7.x, Decl(interfaceExtendsObjectIntersection.ts, 26, 36)) +>C7 : Symbol(C7, Decl(interfaceExtendsObjectIntersection.ts, 24, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) +>x : Symbol(C7.x, Decl(interfaceExtendsObjectIntersection.ts, 25, 36)) declare function fx(x: string): string; ->fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 26, 48)) ->x : Symbol(x, Decl(interfaceExtendsObjectIntersection.ts, 28, 20)) +>fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 25, 48)) +>x : Symbol(x, Decl(interfaceExtendsObjectIntersection.ts, 27, 20)) declare class CX { a: number } ->CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 28, 39)) ->a : Symbol(CX.a, Decl(interfaceExtendsObjectIntersection.ts, 29, 18)) +>CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 27, 39)) +>a : Symbol(CX.a, Decl(interfaceExtendsObjectIntersection.ts, 28, 18)) declare enum EX { A, B, C } ->EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 29, 30)) ->A : Symbol(EX.A, Decl(interfaceExtendsObjectIntersection.ts, 30, 17)) ->B : Symbol(EX.B, Decl(interfaceExtendsObjectIntersection.ts, 30, 20)) ->C : Symbol(EX.C, Decl(interfaceExtendsObjectIntersection.ts, 30, 23)) +>EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 28, 30)) +>A : Symbol(EX.A, Decl(interfaceExtendsObjectIntersection.ts, 29, 17)) +>B : Symbol(EX.B, Decl(interfaceExtendsObjectIntersection.ts, 29, 20)) +>C : Symbol(EX.C, Decl(interfaceExtendsObjectIntersection.ts, 29, 23)) declare namespace NX { export const a = 1 } ->NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 30, 27)) ->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 31, 35)) +>NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 29, 27)) +>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 30, 35)) type T10 = typeof fx; ->T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 31, 43)) ->fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 26, 48)) +>T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 30, 43)) +>fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 25, 48)) type T11 = typeof CX; ->T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) ->CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 28, 39)) +>T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 32, 21)) +>CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 27, 39)) type T12 = typeof EX; ->T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) ->EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 29, 30)) +>T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) +>EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 28, 30)) type T13 = typeof NX; ->T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 35, 21)) ->NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 30, 27)) +>T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) +>NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 29, 27)) interface I10 extends T10 { x: string } ->I10 : Symbol(I10, Decl(interfaceExtendsObjectIntersection.ts, 36, 21)) ->T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 31, 43)) ->x : Symbol(I10.x, Decl(interfaceExtendsObjectIntersection.ts, 38, 27)) +>I10 : Symbol(I10, Decl(interfaceExtendsObjectIntersection.ts, 35, 21)) +>T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 30, 43)) +>x : Symbol(I10.x, Decl(interfaceExtendsObjectIntersection.ts, 37, 27)) interface I11 extends T11 { x: string } ->I11 : Symbol(I11, Decl(interfaceExtendsObjectIntersection.ts, 38, 39)) ->T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) ->x : Symbol(I11.x, Decl(interfaceExtendsObjectIntersection.ts, 39, 27)) +>I11 : Symbol(I11, Decl(interfaceExtendsObjectIntersection.ts, 37, 39)) +>T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 32, 21)) +>x : Symbol(I11.x, Decl(interfaceExtendsObjectIntersection.ts, 38, 27)) interface I12 extends T12 { x: string } ->I12 : Symbol(I12, Decl(interfaceExtendsObjectIntersection.ts, 39, 39)) ->T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) ->x : Symbol(I12.x, Decl(interfaceExtendsObjectIntersection.ts, 40, 27)) +>I12 : Symbol(I12, Decl(interfaceExtendsObjectIntersection.ts, 38, 39)) +>T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) +>x : Symbol(I12.x, Decl(interfaceExtendsObjectIntersection.ts, 39, 27)) interface I13 extends T13 { x: string } ->I13 : Symbol(I13, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) ->T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 35, 21)) ->x : Symbol(I13.x, Decl(interfaceExtendsObjectIntersection.ts, 41, 27)) +>I13 : Symbol(I13, Decl(interfaceExtendsObjectIntersection.ts, 39, 39)) +>T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) +>x : Symbol(I13.x, Decl(interfaceExtendsObjectIntersection.ts, 40, 27)) type Identifiable = { _id: string } & T; ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 43, 18)) ->_id : Symbol(_id, Decl(interfaceExtendsObjectIntersection.ts, 43, 24)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 43, 18)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 42, 18)) +>_id : Symbol(_id, Decl(interfaceExtendsObjectIntersection.ts, 42, 24)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 42, 18)) interface I20 extends Partial { x: string } ->I20 : Symbol(I20, Decl(interfaceExtendsObjectIntersection.ts, 43, 43)) +>I20 : Symbol(I20, Decl(interfaceExtendsObjectIntersection.ts, 42, 43)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I20.x, Decl(interfaceExtendsObjectIntersection.ts, 45, 35)) +>x : Symbol(I20.x, Decl(interfaceExtendsObjectIntersection.ts, 44, 35)) interface I21 extends Readonly { x: string } ->I21 : Symbol(I21, Decl(interfaceExtendsObjectIntersection.ts, 45, 47)) +>I21 : Symbol(I21, Decl(interfaceExtendsObjectIntersection.ts, 44, 47)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I21.x, Decl(interfaceExtendsObjectIntersection.ts, 46, 36)) +>x : Symbol(I21.x, Decl(interfaceExtendsObjectIntersection.ts, 45, 36)) interface I22 extends Identifiable { x: string } ->I22 : Symbol(I22, Decl(interfaceExtendsObjectIntersection.ts, 46, 48)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>I22 : Symbol(I22, Decl(interfaceExtendsObjectIntersection.ts, 45, 48)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I22.x, Decl(interfaceExtendsObjectIntersection.ts, 47, 40)) +>x : Symbol(I22.x, Decl(interfaceExtendsObjectIntersection.ts, 46, 40)) interface I23 extends Identifiable { x: string } ->I23 : Symbol(I23, Decl(interfaceExtendsObjectIntersection.ts, 47, 52)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>I23 : Symbol(I23, Decl(interfaceExtendsObjectIntersection.ts, 46, 52)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 48, 41)) ->x : Symbol(I23.x, Decl(interfaceExtendsObjectIntersection.ts, 48, 55)) +>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 47, 41)) +>x : Symbol(I23.x, Decl(interfaceExtendsObjectIntersection.ts, 47, 55)) class C20 extends Constructor>() { x: string } ->C20 : Symbol(C20, Decl(interfaceExtendsObjectIntersection.ts, 48, 67)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) +>C20 : Symbol(C20, Decl(interfaceExtendsObjectIntersection.ts, 47, 67)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(C20.x, Decl(interfaceExtendsObjectIntersection.ts, 50, 46)) +>x : Symbol(C20.x, Decl(interfaceExtendsObjectIntersection.ts, 49, 46)) class C21 extends Constructor>() { x: string } ->C21 : Symbol(C21, Decl(interfaceExtendsObjectIntersection.ts, 50, 58)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) +>C21 : Symbol(C21, Decl(interfaceExtendsObjectIntersection.ts, 49, 58)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(C21.x, Decl(interfaceExtendsObjectIntersection.ts, 51, 47)) +>x : Symbol(C21.x, Decl(interfaceExtendsObjectIntersection.ts, 50, 47)) class C22 extends Constructor>() { x: string } ->C22 : Symbol(C22, Decl(interfaceExtendsObjectIntersection.ts, 51, 59)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>C22 : Symbol(C22, Decl(interfaceExtendsObjectIntersection.ts, 50, 59)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(C22.x, Decl(interfaceExtendsObjectIntersection.ts, 52, 51)) +>x : Symbol(C22.x, Decl(interfaceExtendsObjectIntersection.ts, 51, 51)) class C23 extends Constructor>() { x: string } ->C23 : Symbol(C23, Decl(interfaceExtendsObjectIntersection.ts, 52, 63)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>C23 : Symbol(C23, Decl(interfaceExtendsObjectIntersection.ts, 51, 63)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 53, 49)) ->x : Symbol(C23.x, Decl(interfaceExtendsObjectIntersection.ts, 53, 66)) +>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 52, 49)) +>x : Symbol(C23.x, Decl(interfaceExtendsObjectIntersection.ts, 52, 66)) diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.types b/tests/baselines/reference/interfaceExtendsObjectIntersection.types index 1ff550df7b4..50ef0339b93 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.types +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts === - type T1 = { a: number }; >T1 : T1 >a : number diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt index 839474b3bdc..155cf4bd5ad 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt +++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt @@ -1,68 +1,67 @@ -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(8,11): error TS2430: Interface 'I1' incorrectly extends interface 'T1'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(7,11): error TS2430: Interface 'I1' incorrectly extends interface 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(9,11): error TS2430: Interface 'I2' incorrectly extends interface 'T2'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(8,11): error TS2430: Interface 'I2' incorrectly extends interface 'T2'. Type 'I2' is not assignable to type '{ b: number; }'. Types of property 'b' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(10,11): error TS2430: Interface 'I3' incorrectly extends interface 'number[]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(9,11): error TS2430: Interface 'I3' incorrectly extends interface 'number[]'. Types of property 'length' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(11,11): error TS2430: Interface 'I4' incorrectly extends interface '[string, number]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(10,11): error TS2430: Interface 'I4' incorrectly extends interface '[string, number]'. Types of property '0' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(12,11): error TS2430: Interface 'I5' incorrectly extends interface 'T5'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(11,11): error TS2430: Interface 'I5' incorrectly extends interface 'T5'. Types of property 'c' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(17,7): error TS2415: Class 'C1' incorrectly extends base class 'T1'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(16,7): error TS2415: Class 'C1' incorrectly extends base class 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(18,7): error TS2415: Class 'C2' incorrectly extends base class 'T2'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(17,7): error TS2415: Class 'C2' incorrectly extends base class 'T2'. Type 'C2' is not assignable to type '{ b: number; }'. Types of property 'b' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(19,7): error TS2415: Class 'C3' incorrectly extends base class 'number[]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(18,7): error TS2415: Class 'C3' incorrectly extends base class 'number[]'. Types of property 'length' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(20,7): error TS2415: Class 'C4' incorrectly extends base class '[string, number]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(19,7): error TS2415: Class 'C4' incorrectly extends base class '[string, number]'. Types of property '0' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(21,7): error TS2415: Class 'C5' incorrectly extends base class 'T5'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(20,7): error TS2415: Class 'C5' incorrectly extends base class 'T5'. Types of property 'c' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(31,11): error TS2430: Interface 'I10' incorrectly extends interface 'typeof CX'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(30,11): error TS2430: Interface 'I10' incorrectly extends interface 'typeof CX'. Types of property 'a' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(32,11): error TS2430: Interface 'I11' incorrectly extends interface 'typeof EX'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(31,11): error TS2430: Interface 'I11' incorrectly extends interface 'typeof EX'. Types of property 'C' are incompatible. Type 'string' is not assignable to type 'EX'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,11): error TS2430: Interface 'I12' incorrectly extends interface 'typeof NX'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(32,11): error TS2430: Interface 'I12' incorrectly extends interface 'typeof NX'. Types of property 'a' are incompatible. Type 'number' is not assignable to type '"hello"'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2411: Property 'a' of type 'string' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2411: Property 'prototype' of type 'CX' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(35,29): error TS2413: Numeric index type 'string' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(36,29): error TS2411: Property 'a' of type '"hello"' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(40,11): error TS2430: Interface 'I20' incorrectly extends interface 'Partial'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,29): error TS2411: Property 'a' of type 'string' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,29): error TS2411: Property 'prototype' of type 'CX' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2413: Numeric index type 'string' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(35,29): error TS2411: Property 'a' of type '"hello"' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(39,11): error TS2430: Interface 'I20' incorrectly extends interface 'Partial'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(41,11): error TS2430: Interface 'I21' incorrectly extends interface 'Readonly'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(40,11): error TS2430: Interface 'I21' incorrectly extends interface 'Readonly'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(42,11): error TS2430: Interface 'I22' incorrectly extends interface 'Identifiable'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(41,11): error TS2430: Interface 'I22' incorrectly extends interface 'Identifiable'. Type 'I22' is not assignable to type 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(43,11): error TS2430: Interface 'I23' incorrectly extends interface 'Identifiable'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(42,11): error TS2430: Interface 'I23' incorrectly extends interface 'Identifiable'. Type 'I23' is not assignable to type 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(47,23): error TS2312: An interface may only extend a class or another interface. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(48,26): error TS2312: An interface may only extend a class or another interface. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(46,23): error TS2312: An interface may only extend a class or another interface. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(47,26): error TS2312: An interface may only extend a class or another interface. ==== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts (23 errors) ==== - type T1 = { a: number }; type T2 = T1 & { b: number }; type T3 = number[]; diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js index 61f84b2f7fe..7ae09d693ff 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js +++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js @@ -1,5 +1,4 @@ //// [interfaceExtendsObjectIntersectionErrors.ts] - type T1 = { a: number }; type T2 = T1 & { b: number }; type T3 = number[]; diff --git a/tests/baselines/reference/interfaceWithOptionalProperty.js b/tests/baselines/reference/interfaceWithOptionalProperty.js index 5e62fb5257b..dd70f245382 100644 --- a/tests/baselines/reference/interfaceWithOptionalProperty.js +++ b/tests/baselines/reference/interfaceWithOptionalProperty.js @@ -1,5 +1,4 @@ //// [interfaceWithOptionalProperty.ts] - interface I { x?: number; } diff --git a/tests/baselines/reference/interfaceWithOptionalProperty.symbols b/tests/baselines/reference/interfaceWithOptionalProperty.symbols index 90e5b666693..c22c1a67c3b 100644 --- a/tests/baselines/reference/interfaceWithOptionalProperty.symbols +++ b/tests/baselines/reference/interfaceWithOptionalProperty.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/interfaceWithOptionalProperty.ts === - interface I { >I : Symbol(I, Decl(interfaceWithOptionalProperty.ts, 0, 0)) x?: number; ->x : Symbol(I.x, Decl(interfaceWithOptionalProperty.ts, 1, 13)) +>x : Symbol(I.x, Decl(interfaceWithOptionalProperty.ts, 0, 13)) } diff --git a/tests/baselines/reference/interfaceWithOptionalProperty.types b/tests/baselines/reference/interfaceWithOptionalProperty.types index 862857483da..667e410748c 100644 --- a/tests/baselines/reference/interfaceWithOptionalProperty.types +++ b/tests/baselines/reference/interfaceWithOptionalProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/interfaceWithOptionalProperty.ts === - interface I { >I : I diff --git a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt index ecbd9ec293c..ab003895ff0 100644 --- a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt +++ b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(5,5): error TS1070: 'private' modifier cannot appear on a type member. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(9,5): error TS1070: 'private' modifier cannot appear on a type member. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,5): error TS1070: 'private' modifier cannot appear on a type member. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(4,5): error TS1070: 'private' modifier cannot appear on a type member. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(8,5): error TS1070: 'private' modifier cannot appear on a type member. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,5): error TS1070: 'private' modifier cannot appear on a type member. ==== tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts (3 errors) ==== - // interfaces do not permit private members, these are errors interface I { diff --git a/tests/baselines/reference/interfaceWithPrivateMember.js b/tests/baselines/reference/interfaceWithPrivateMember.js index d59037cf058..06bcb537f55 100644 --- a/tests/baselines/reference/interfaceWithPrivateMember.js +++ b/tests/baselines/reference/interfaceWithPrivateMember.js @@ -1,5 +1,4 @@ //// [interfaceWithPrivateMember.ts] - // interfaces do not permit private members, these are errors interface I { diff --git a/tests/baselines/reference/intrinsics.errors.txt b/tests/baselines/reference/intrinsics.errors.txt index 342b84e02b9..5692f057903 100644 --- a/tests/baselines/reference/intrinsics.errors.txt +++ b/tests/baselines/reference/intrinsics.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/intrinsics.ts(2,21): error TS2304: Cannot find name 'hasOwnProperty'. -tests/cases/compiler/intrinsics.ts(2,21): error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'. -tests/cases/compiler/intrinsics.ts(11,1): error TS2304: Cannot find name '__proto__'. +tests/cases/compiler/intrinsics.ts(1,21): error TS2304: Cannot find name 'hasOwnProperty'. +tests/cases/compiler/intrinsics.ts(1,21): error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'. +tests/cases/compiler/intrinsics.ts(10,1): error TS2304: Cannot find name '__proto__'. ==== tests/cases/compiler/intrinsics.ts (3 errors) ==== - var hasOwnProperty: hasOwnProperty; // Error ~~~~~~~~~~~~~~ !!! error TS2304: Cannot find name 'hasOwnProperty'. diff --git a/tests/baselines/reference/intrinsics.js b/tests/baselines/reference/intrinsics.js index 548c72b1b40..82f6ceda758 100644 --- a/tests/baselines/reference/intrinsics.js +++ b/tests/baselines/reference/intrinsics.js @@ -1,5 +1,4 @@ //// [intrinsics.ts] - var hasOwnProperty: hasOwnProperty; // Error module m1 { diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt index 15983bd1fc4..65fd55b763b 100644 --- a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(9,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(8,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts (6 errors) ==== - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.js b/tests/baselines/reference/invalidDoWhileBreakStatements.js index 4f48a890aa6..807d58a8fea 100644 --- a/tests/baselines/reference/invalidDoWhileBreakStatements.js +++ b/tests/baselines/reference/invalidDoWhileBreakStatements.js @@ -1,5 +1,4 @@ //// [invalidDoWhileBreakStatements.ts] - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt index 3a520209293..e9643394d12 100644 --- a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(9,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(8,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.js b/tests/baselines/reference/invalidDoWhileContinueStatements.js index b77259159a9..21a10a3451b 100644 --- a/tests/baselines/reference/invalidDoWhileContinueStatements.js +++ b/tests/baselines/reference/invalidDoWhileContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidDoWhileContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForBreakStatements.errors.txt b/tests/baselines/reference/invalidForBreakStatements.errors.txt index 57ae1d32c8e..50e4013c0ea 100644 --- a/tests/baselines/reference/invalidForBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidForBreakStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(9,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(8,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(36,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts (6 errors) ==== - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForBreakStatements.js b/tests/baselines/reference/invalidForBreakStatements.js index 50096e16720..5e3430ecb41 100644 --- a/tests/baselines/reference/invalidForBreakStatements.js +++ b/tests/baselines/reference/invalidForBreakStatements.js @@ -1,5 +1,4 @@ //// [invalidForBreakStatements.ts] - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForContinueStatements.errors.txt b/tests/baselines/reference/invalidForContinueStatements.errors.txt index 9ebfae57e9f..3af47370df1 100644 --- a/tests/baselines/reference/invalidForContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidForContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(9,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(8,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(36,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForContinueStatements.js b/tests/baselines/reference/invalidForContinueStatements.js index 7a3513bb2a3..2db1ce69ede 100644 --- a/tests/baselines/reference/invalidForContinueStatements.js +++ b/tests/baselines/reference/invalidForContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidForContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForInBreakStatements.errors.txt b/tests/baselines/reference/invalidForInBreakStatements.errors.txt index b1f5d64f973..d83304ab1c6 100644 --- a/tests/baselines/reference/invalidForInBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidForInBreakStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(9,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(8,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts (6 errors) ==== - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForInBreakStatements.js b/tests/baselines/reference/invalidForInBreakStatements.js index 11517f2a020..1784b9a57a6 100644 --- a/tests/baselines/reference/invalidForInBreakStatements.js +++ b/tests/baselines/reference/invalidForInBreakStatements.js @@ -1,5 +1,4 @@ //// [invalidForInBreakStatements.ts] - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForInContinueStatements.errors.txt b/tests/baselines/reference/invalidForInContinueStatements.errors.txt index f20d9c6e81c..7353a22d9cd 100644 --- a/tests/baselines/reference/invalidForInContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidForInContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(9,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(8,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForInContinueStatements.js b/tests/baselines/reference/invalidForInContinueStatements.js index 5eb0e10bf53..94020d00f2b 100644 --- a/tests/baselines/reference/invalidForInContinueStatements.js +++ b/tests/baselines/reference/invalidForInContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidForInContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidThrowStatement.errors.txt b/tests/baselines/reference/invalidThrowStatement.errors.txt index 3002bce2f1f..b30549a217c 100644 --- a/tests/baselines/reference/invalidThrowStatement.errors.txt +++ b/tests/baselines/reference/invalidThrowStatement.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(2,6): error TS1109: Expression expected. -tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(1,6): error TS1109: Expression expected. +tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,1): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts (2 errors) ==== - throw; ~ !!! error TS1109: Expression expected. diff --git a/tests/baselines/reference/invalidThrowStatement.js b/tests/baselines/reference/invalidThrowStatement.js index 674dacf5c17..4b794ab3d51 100644 --- a/tests/baselines/reference/invalidThrowStatement.js +++ b/tests/baselines/reference/invalidThrowStatement.js @@ -1,5 +1,4 @@ //// [invalidThrowStatement.ts] - throw; export throw null; diff --git a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt index e7a9ed13c40..462b244efd4 100644 --- a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(9,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(8,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidWhileContinueStatements.js b/tests/baselines/reference/invalidWhileContinueStatements.js index 16350e9b561..b8234bf9604 100644 --- a/tests/baselines/reference/invalidWhileContinueStatements.js +++ b/tests/baselines/reference/invalidWhileContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidWhileContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.js b/tests/baselines/reference/isDeclarationVisibleNodeKinds.js index 07bc9994742..cf25d8e7e23 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.js +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.js @@ -1,5 +1,4 @@ //// [isDeclarationVisibleNodeKinds.ts] - // Function types module schema { export function createValidator1(schema: any): (data: T) => T { diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols index ecc68121f37..06d1f087d09 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/isDeclarationVisibleNodeKinds.ts === - // Function types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator1(schema: any): (data: T) => T { ->createValidator1 : Symbol(createValidator1, Decl(isDeclarationVisibleNodeKinds.ts, 2, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 3, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 3, 52)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 3, 55)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 3, 52)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 3, 52)) +>createValidator1 : Symbol(createValidator1, Decl(isDeclarationVisibleNodeKinds.ts, 1, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 2, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 2, 52)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 2, 55)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 2, 52)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 2, 52)) return undefined; >undefined : Symbol(undefined) @@ -19,15 +18,15 @@ module schema { // Constructor types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator2(schema: any): new (data: T) => T { ->createValidator2 : Symbol(createValidator2, Decl(isDeclarationVisibleNodeKinds.ts, 9, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 10, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 10, 56)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 10, 59)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 10, 56)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 10, 56)) +>createValidator2 : Symbol(createValidator2, Decl(isDeclarationVisibleNodeKinds.ts, 8, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 9, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 9, 56)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 9, 59)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 9, 56)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 9, 56)) return undefined; >undefined : Symbol(undefined) @@ -36,15 +35,15 @@ module schema { // union types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator3(schema: any): number | { new (data: T): T; } { ->createValidator3 : Symbol(createValidator3, Decl(isDeclarationVisibleNodeKinds.ts, 16, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 17, 38)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 17, 68)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 17, 71)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 17, 68)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 17, 68)) +>createValidator3 : Symbol(createValidator3, Decl(isDeclarationVisibleNodeKinds.ts, 15, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 16, 38)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 16, 68)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 16, 71)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 16, 68)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 16, 68)) return undefined; >undefined : Symbol(undefined) @@ -53,15 +52,15 @@ module schema { // Array types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator4(schema: any): { new (data: T): T; }[] { ->createValidator4 : Symbol(createValidator4, Decl(isDeclarationVisibleNodeKinds.ts, 23, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 24, 38)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 24, 59)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 24, 62)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 24, 59)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 24, 59)) +>createValidator4 : Symbol(createValidator4, Decl(isDeclarationVisibleNodeKinds.ts, 22, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 23, 38)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 23, 59)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 23, 62)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 23, 59)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 23, 59)) return undefined; >undefined : Symbol(undefined) @@ -71,15 +70,15 @@ module schema { // TypeLiterals module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator5(schema: any): { new (data: T): T } { ->createValidator5 : Symbol(createValidator5, Decl(isDeclarationVisibleNodeKinds.ts, 31, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 32, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 32, 58)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 32, 61)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 32, 58)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 32, 58)) +>createValidator5 : Symbol(createValidator5, Decl(isDeclarationVisibleNodeKinds.ts, 30, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 31, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 31, 58)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 31, 61)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 31, 58)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 31, 58)) return undefined; >undefined : Symbol(undefined) @@ -88,15 +87,15 @@ module schema { // Tuple types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator6(schema: any): [ new (data: T) => T, number] { ->createValidator6 : Symbol(createValidator6, Decl(isDeclarationVisibleNodeKinds.ts, 38, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 39, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 39, 58)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 39, 61)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 39, 58)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 39, 58)) +>createValidator6 : Symbol(createValidator6, Decl(isDeclarationVisibleNodeKinds.ts, 37, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 38, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 38, 58)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 38, 61)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 38, 58)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 38, 58)) return undefined; >undefined : Symbol(undefined) @@ -105,15 +104,15 @@ module schema { // Paren Types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator7(schema: any): (new (data: T)=>T )[] { ->createValidator7 : Symbol(createValidator7, Decl(isDeclarationVisibleNodeKinds.ts, 45, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 46, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 46, 57)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 46, 60)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 46, 57)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 46, 57)) +>createValidator7 : Symbol(createValidator7, Decl(isDeclarationVisibleNodeKinds.ts, 44, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 45, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 45, 57)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 45, 60)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 45, 57)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 45, 57)) return undefined; >undefined : Symbol(undefined) @@ -122,16 +121,16 @@ module schema { // Type reference module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator8(schema: any): Array<{ (data: T) : T}> { ->createValidator8 : Symbol(createValidator8, Decl(isDeclarationVisibleNodeKinds.ts, 52, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 53, 37)) +>createValidator8 : Symbol(createValidator8, Decl(isDeclarationVisibleNodeKinds.ts, 51, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 52, 37)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 53, 63)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 52, 60)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 52, 63)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 52, 60)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 52, 60)) return undefined; >undefined : Symbol(undefined) @@ -140,29 +139,29 @@ module schema { module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export class T { ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 59, 15)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 58, 15)) get createValidator9(): (data: T) => T { ->createValidator9 : Symbol(T.createValidator9, Decl(isDeclarationVisibleNodeKinds.ts, 60, 20)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 61, 33)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 61, 36)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 61, 33)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 61, 33)) +>createValidator9 : Symbol(T.createValidator9, Decl(isDeclarationVisibleNodeKinds.ts, 59, 20)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 60, 33)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 60, 36)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 60, 33)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 60, 33)) return undefined; >undefined : Symbol(undefined) } set createValidator10(v: (data: T) => T) { ->createValidator10 : Symbol(T.createValidator10, Decl(isDeclarationVisibleNodeKinds.ts, 63, 9)) ->v : Symbol(v, Decl(isDeclarationVisibleNodeKinds.ts, 65, 30)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 65, 34)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 65, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 65, 34)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 65, 34)) +>createValidator10 : Symbol(T.createValidator10, Decl(isDeclarationVisibleNodeKinds.ts, 62, 9)) +>v : Symbol(v, Decl(isDeclarationVisibleNodeKinds.ts, 64, 30)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 64, 34)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 64, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 64, 34)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 64, 34)) } } } diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.types b/tests/baselines/reference/isDeclarationVisibleNodeKinds.types index b3fe8d684b7..43d27f026e8 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.types +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.types @@ -1,5 +1,4 @@ === tests/cases/compiler/isDeclarationVisibleNodeKinds.ts === - // Function types module schema { >schema : typeof schema diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt index e0eef7d892d..642e38cc6e0 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/file1.ts(3,20): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. +tests/cases/compiler/file1.ts(1,20): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/file1.ts (1 errors) ==== - - declare const enum E { X = 1} ~ !!! error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js index 6d9fc540d9a..44b6e1c1d76 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js @@ -1,6 +1,4 @@ //// [file1.ts] - - declare const enum E { X = 1} export var y; diff --git a/tests/baselines/reference/isolatedModulesDeclaration.errors.txt b/tests/baselines/reference/isolatedModulesDeclaration.errors.txt index 2997acd58ac..09a655c6da0 100644 --- a/tests/baselines/reference/isolatedModulesDeclaration.errors.txt +++ b/tests/baselines/reference/isolatedModulesDeclaration.errors.txt @@ -3,5 +3,4 @@ error TS5053: Option 'declaration' cannot be specified with option 'isolatedModu !!! error TS5053: Option 'declaration' cannot be specified with option 'isolatedModules'. ==== tests/cases/compiler/file1.ts (0 errors) ==== - export var x; \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesDeclaration.js b/tests/baselines/reference/isolatedModulesDeclaration.js index bb3e560a2f8..9709118084f 100644 --- a/tests/baselines/reference/isolatedModulesDeclaration.js +++ b/tests/baselines/reference/isolatedModulesDeclaration.js @@ -1,5 +1,4 @@ //// [file1.ts] - export var x; //// [file1.js] diff --git a/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt b/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt index 60d2ca987e4..c536f487637 100644 --- a/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt +++ b/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/file1.ts(2,17): error TS2307: Cannot find module 'module'. -tests/cases/compiler/file1.ts(3,18): error TS2307: Cannot find module 'module'. -tests/cases/compiler/file1.ts(4,21): error TS2307: Cannot find module 'module'. -tests/cases/compiler/file1.ts(12,18): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(1,17): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(2,18): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(3,21): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(11,18): error TS2307: Cannot find module 'module'. ==== tests/cases/compiler/file1.ts (4 errors) ==== - import {c} from "module" ~~~~~~~~ !!! error TS2307: Cannot find module 'module'. diff --git a/tests/baselines/reference/isolatedModulesImportExportElision.js b/tests/baselines/reference/isolatedModulesImportExportElision.js index 5aac4a64186..a75fab450c2 100644 --- a/tests/baselines/reference/isolatedModulesImportExportElision.js +++ b/tests/baselines/reference/isolatedModulesImportExportElision.js @@ -1,5 +1,4 @@ //// [file1.ts] - import {c} from "module" import {c2} from "module" import * as ns from "module" diff --git a/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt b/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt index 2579ffc4a90..34ff251c167 100644 --- a/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt +++ b/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt @@ -3,5 +3,4 @@ error TS5053: Option 'noEmitOnError' cannot be specified with option 'isolatedMo !!! error TS5053: Option 'noEmitOnError' cannot be specified with option 'isolatedModules'. ==== tests/cases/compiler/file1.ts (0 errors) ==== - export var x; \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt b/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt index 29353b3284a..6d0f12bb1ab 100644 --- a/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt +++ b/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/file1.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/file1.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/file1.ts (1 errors) ==== - var x; ~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesNoExternalModule.js b/tests/baselines/reference/isolatedModulesNoExternalModule.js index 52cdbaa1402..67545d5429f 100644 --- a/tests/baselines/reference/isolatedModulesNoExternalModule.js +++ b/tests/baselines/reference/isolatedModulesNoExternalModule.js @@ -1,5 +1,4 @@ //// [file1.ts] - var x; //// [file1.js] diff --git a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js index 396fc597911..f48f53d93fc 100644 --- a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js +++ b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js @@ -1,5 +1,4 @@ //// [file1.ts] - const enum E { X = 100 }; var e = E.X; export var x; diff --git a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols index 4755208b21a..5060bcc9e6f 100644 --- a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols +++ b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/file1.ts === - const enum E { X = 100 }; >E : Symbol(E, Decl(file1.ts, 0, 0)) ->X : Symbol(E.X, Decl(file1.ts, 1, 14)) +>X : Symbol(E.X, Decl(file1.ts, 0, 14)) var e = E.X; ->e : Symbol(e, Decl(file1.ts, 2, 3)) ->E.X : Symbol(E.X, Decl(file1.ts, 1, 14)) +>e : Symbol(e, Decl(file1.ts, 1, 3)) +>E.X : Symbol(E.X, Decl(file1.ts, 0, 14)) >E : Symbol(E, Decl(file1.ts, 0, 0)) ->X : Symbol(E.X, Decl(file1.ts, 1, 14)) +>X : Symbol(E.X, Decl(file1.ts, 0, 14)) export var x; ->x : Symbol(x, Decl(file1.ts, 3, 10)) +>x : Symbol(x, Decl(file1.ts, 2, 10)) diff --git a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types index 0412a79c479..1ac53071e4c 100644 --- a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types +++ b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - const enum E { X = 100 }; >E : E >X : E diff --git a/tests/baselines/reference/isolatedModulesOut.errors.txt b/tests/baselines/reference/isolatedModulesOut.errors.txt index 157ae98fcb3..5581ece62e6 100644 --- a/tests/baselines/reference/isolatedModulesOut.errors.txt +++ b/tests/baselines/reference/isolatedModulesOut.errors.txt @@ -1,11 +1,10 @@ error TS5053: Option 'out' cannot be specified with option 'isolatedModules'. -tests/cases/compiler/file1.ts(2,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. +tests/cases/compiler/file1.ts(1,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. tests/cases/compiler/file2.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. !!! error TS5053: Option 'out' cannot be specified with option 'isolatedModules'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - export var x; ~~~~~~~~~~~~~ !!! error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. diff --git a/tests/baselines/reference/isolatedModulesOut.js b/tests/baselines/reference/isolatedModulesOut.js index 44f319e1031..fe995704a46 100644 --- a/tests/baselines/reference/isolatedModulesOut.js +++ b/tests/baselines/reference/isolatedModulesOut.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/isolatedModulesOut.ts] //// //// [file1.ts] - export var x; //// [file2.ts] var y; diff --git a/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt index 680070a73c8..d24da5e09cc 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-AMD.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-AMD.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-AMD.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-AMD.js b/tests/baselines/reference/isolatedModulesPlainFile-AMD.js index 4ed1fdf2c77..ffa998ba2d8 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-AMD.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-AMD.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-AMD.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt index d1f0ca3caad..43d18c54eb9 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-CommonJS.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-CommonJS.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-CommonJS.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js index 38739a700ef..a967914a9ea 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-CommonJS.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt index d46fce22fd7..56316072aff 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-ES6.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-ES6.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-ES6.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-ES6.js b/tests/baselines/reference/isolatedModulesPlainFile-ES6.js index 245d3fe668f..446f8075bb1 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-ES6.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-ES6.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-ES6.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt index fe1a2f80018..b1e2ba643fa 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-System.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-System.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-System.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-System.js b/tests/baselines/reference/isolatedModulesPlainFile-System.js index 39b648e071a..2ebab90f120 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-System.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-System.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-System.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt index 24c5c86f8f8..29dfe4f67fb 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-UMD.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-UMD.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-UMD.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-UMD.js b/tests/baselines/reference/isolatedModulesPlainFile-UMD.js index f37962a84ab..08cfdc3e54a 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-UMD.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-UMD.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-UMD.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesSourceMap.js b/tests/baselines/reference/isolatedModulesSourceMap.js index 02d394752d1..9e2869e24e5 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.js +++ b/tests/baselines/reference/isolatedModulesSourceMap.js @@ -1,5 +1,4 @@ //// [file1.ts] - export var x = 1; //// [file1.js] diff --git a/tests/baselines/reference/isolatedModulesSourceMap.js.map b/tests/baselines/reference/isolatedModulesSourceMap.js.map index 6c99c273797..139169df315 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.js.map +++ b/tests/baselines/reference/isolatedModulesSourceMap.js.map @@ -1,2 +1,2 @@ //// [file1.js.map] -{"version":3,"file":"file1.js","sourceRoot":"","sources":["file1.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"file1.js","sourceRoot":"","sources":["file1.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt b/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt index a9b2d98d967..a420d8f8e4f 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt +++ b/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt @@ -18,8 +18,7 @@ sourceFile:file1.ts 7 > ^ 8 > ^ 9 > ^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >export 3 > 4 > var @@ -27,13 +26,13 @@ sourceFile:file1.ts 6 > = 7 > 1 8 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 7) Source(2, 7) + SourceIndex(0) -3 >Emitted(1, 8) Source(2, 8) + SourceIndex(0) -4 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) -5 >Emitted(1, 13) Source(2, 13) + SourceIndex(0) -6 >Emitted(1, 16) Source(2, 16) + SourceIndex(0) -7 >Emitted(1, 17) Source(2, 17) + SourceIndex(0) -8 >Emitted(1, 18) Source(2, 18) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 7) Source(1, 7) + SourceIndex(0) +3 >Emitted(1, 8) Source(1, 8) + SourceIndex(0) +4 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) +5 >Emitted(1, 13) Source(1, 13) + SourceIndex(0) +6 >Emitted(1, 16) Source(1, 16) + SourceIndex(0) +7 >Emitted(1, 17) Source(1, 17) + SourceIndex(0) +8 >Emitted(1, 18) Source(1, 18) + SourceIndex(0) --- >>>//# sourceMappingURL=file1.js.map \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesSourceMap.symbols b/tests/baselines/reference/isolatedModulesSourceMap.symbols index 2f2d16d8ad0..bfd3360315a 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.symbols +++ b/tests/baselines/reference/isolatedModulesSourceMap.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export var x = 1; ->x : Symbol(x, Decl(file1.ts, 1, 10)) +>x : Symbol(x, Decl(file1.ts, 0, 10)) diff --git a/tests/baselines/reference/isolatedModulesSourceMap.types b/tests/baselines/reference/isolatedModulesSourceMap.types index 2ac7b1f2f65..4d09a6b72c4 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.types +++ b/tests/baselines/reference/isolatedModulesSourceMap.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/isolatedModulesWithDeclarationFile.js b/tests/baselines/reference/isolatedModulesWithDeclarationFile.js index 42d091b6108..425423bd7e1 100644 --- a/tests/baselines/reference/isolatedModulesWithDeclarationFile.js +++ b/tests/baselines/reference/isolatedModulesWithDeclarationFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/isolatedModulesWithDeclarationFile.ts] //// //// [file1.d.ts] - declare function foo(): void; //// [file1.ts] diff --git a/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols b/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols index bccf8ce9357..a60e6b38a41 100644 --- a/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols +++ b/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare function foo(): void; >foo : Symbol(foo, Decl(file1.d.ts, 0, 0)) diff --git a/tests/baselines/reference/isolatedModulesWithDeclarationFile.types b/tests/baselines/reference/isolatedModulesWithDeclarationFile.types index 94adc5fa27e..06eb150bb5e 100644 --- a/tests/baselines/reference/isolatedModulesWithDeclarationFile.types +++ b/tests/baselines/reference/isolatedModulesWithDeclarationFile.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare function foo(): void; >foo : () => void diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.js b/tests/baselines/reference/isomorphicMappedTypeInference.js index 560c926877a..9c4e8c9e9f1 100644 --- a/tests/baselines/reference/isomorphicMappedTypeInference.js +++ b/tests/baselines/reference/isomorphicMappedTypeInference.js @@ -1,5 +1,4 @@ //// [isomorphicMappedTypeInference.ts] - type Box = { value: T; } diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.symbols b/tests/baselines/reference/isomorphicMappedTypeInference.symbols index 93ce825c35d..6c638f442c8 100644 --- a/tests/baselines/reference/isomorphicMappedTypeInference.symbols +++ b/tests/baselines/reference/isomorphicMappedTypeInference.symbols @@ -1,420 +1,419 @@ === tests/cases/conformance/types/mapped/isomorphicMappedTypeInference.ts === - type Box = { >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 1, 9)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 0, 9)) value: T; ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 1, 9)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 0, 9)) } type Boxified = { ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 5, 14)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 4, 14)) [P in keyof T]: Box; ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 6, 5)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 5, 14)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 5, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 4, 14)) >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 5, 14)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 6, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 4, 14)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 5, 5)) } function box(x: T): Box { ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 9, 13)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 9, 16)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 9, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 8, 13)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 8, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 8, 13)) >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 9, 13)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 8, 13)) return { value: x }; ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 10, 12)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 9, 16)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 9, 12)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 8, 16)) } function unbox(x: Box): T { ->unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 11, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 13, 15)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 13, 18)) +>unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 10, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 12, 18)) >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 13, 15)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 13, 15)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15)) return x.value; ->x.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 13, 18)) ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) +>x.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 12, 18)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) } function boxify(obj: T): Boxified { ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 17, 19)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 16, 19)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) let result = {} as Boxified; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 18, 7)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) for (let k in obj) { ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 19, 12)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 17, 19)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 18, 12)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 16, 19)) result[k] = box(obj[k]); ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 18, 7)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 19, 12)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 17, 19)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 19, 12)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 18, 12)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 16, 19)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 18, 12)) } return result; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 18, 7)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7)) } function unboxify(obj: Boxified): T { ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 25, 21)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) let result = {} as T; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 26, 7)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) for (let k in obj) { ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 27, 12)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 25, 21)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21)) result[k] = unbox(obj[k]); ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 26, 7)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 27, 12)) ->unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 11, 1)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 25, 21)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 27, 12)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12)) +>unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 10, 1)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12)) } return result; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 26, 7)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7)) } function assignBoxified(obj: Boxified, values: T) { ->assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 31, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 33, 24)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 33, 27)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 33, 24)) ->values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 33, 44)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 33, 24)) +>assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 30, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 32, 24)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 32, 27)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 32, 24)) +>values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 32, 24)) for (let k in values) { ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 34, 12)) ->values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 33, 44)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12)) +>values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44)) obj[k].value = values[k]; ->obj[k].value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 33, 27)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 34, 12)) ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 33, 44)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 34, 12)) +>obj[k].value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 32, 27)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12)) } } function f1() { ->f1 : Symbol(f1, Decl(isomorphicMappedTypeInference.ts, 37, 1)) +>f1 : Symbol(f1, Decl(isomorphicMappedTypeInference.ts, 36, 1)) let v = { ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 40, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 39, 7)) a: 42, ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 40, 13)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 39, 13)) b: "hello", ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 41, 14)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 40, 14)) c: true ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 42, 19)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 41, 19)) }; let b = boxify(v); ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 45, 7)) ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 40, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 44, 7)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 39, 7)) let x: number = b.a.value; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 46, 7)) ->b.a.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 45, 7)) +>b.a.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) >b.a : Symbol(a) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 45, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 44, 7)) >a : Symbol(a) ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) } function f2() { ->f2 : Symbol(f2, Decl(isomorphicMappedTypeInference.ts, 47, 1)) +>f2 : Symbol(f2, Decl(isomorphicMappedTypeInference.ts, 46, 1)) let b = { ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 50, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 49, 7)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 50, 13)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 49, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 51, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 50, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 52, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 51, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }; let v = unboxify(b); ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 55, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 50, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 54, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 49, 7)) let x: number = v.a; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 56, 7)) ->v.a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 50, 13)) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 55, 7)) ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 50, 13)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 55, 7)) +>v.a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 49, 13)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 54, 7)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 49, 13)) } function f3() { ->f3 : Symbol(f3, Decl(isomorphicMappedTypeInference.ts, 57, 1)) +>f3 : Symbol(f3, Decl(isomorphicMappedTypeInference.ts, 56, 1)) let b = { ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 60, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 59, 7)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 60, 13)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 59, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 61, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 60, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 62, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 61, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }; assignBoxified(b, { c: false }); ->assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 31, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 60, 7)) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 65, 23)) +>assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 30, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 59, 7)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 64, 23)) } function f4() { ->f4 : Symbol(f4, Decl(isomorphicMappedTypeInference.ts, 66, 1)) +>f4 : Symbol(f4, Decl(isomorphicMappedTypeInference.ts, 65, 1)) let b = { ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 69, 13)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 68, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 70, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 71, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 70, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }; b = boxify(unboxify(b)); ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) b = unboxify(boxify(b)); ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) } function makeRecord(obj: { [P in K]: T }) { ->makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 76, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 78, 20)) ->K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 78, 22)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 78, 41)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 78, 49)) ->K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 78, 22)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 78, 20)) +>makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 75, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 77, 20)) +>K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 77, 22)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 77, 41)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 77, 49)) +>K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 77, 22)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 77, 20)) return obj; ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 78, 41)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 77, 41)) } function f5(s: string) { ->f5 : Symbol(f5, Decl(isomorphicMappedTypeInference.ts, 80, 1)) ->s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 82, 12)) +>f5 : Symbol(f5, Decl(isomorphicMappedTypeInference.ts, 79, 1)) +>s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 81, 12)) let b = makeRecord({ ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 83, 7)) ->makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 76, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 82, 7)) +>makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 75, 1)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 83, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 82, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 84, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 83, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 85, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 84, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }); let v = unboxify(b); ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 88, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 83, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 87, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 82, 7)) let x: string | number | boolean = v.a; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 89, 7)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 88, 7)) >v.a : Symbol(a) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 88, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 87, 7)) >a : Symbol(a) } function makeDictionary(obj: { [x: string]: T }) { ->makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 90, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 92, 24)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 92, 27)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 92, 35)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 92, 24)) +>makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 89, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 91, 24)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 91, 27)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 91, 35)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 91, 24)) return obj; ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 92, 27)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 91, 27)) } function f6(s: string) { ->f6 : Symbol(f6, Decl(isomorphicMappedTypeInference.ts, 94, 1)) ->s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 96, 12)) +>f6 : Symbol(f6, Decl(isomorphicMappedTypeInference.ts, 93, 1)) +>s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 95, 12)) let b = makeDictionary({ ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 97, 7)) ->makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 90, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 96, 7)) +>makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 89, 1)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 97, 28)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 96, 28)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 98, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 97, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 99, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 98, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }); let v = unboxify(b); ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 102, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 97, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 101, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 96, 7)) let x: string | number | boolean = v[s]; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 103, 7)) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 102, 7)) ->s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 96, 12)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 102, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 101, 7)) +>s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 95, 12)) } declare function validate(obj: { [P in keyof T]?: T[P] }): T; ->validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 104, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 106, 29)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) +>validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 103, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 105, 29)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 105, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 105, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) declare function clone(obj: { readonly [P in keyof T]: T[P] }): T; ->clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 106, 64)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 107, 26)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 43)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 43)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) +>clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 105, 64)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 106, 26)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 43)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 43)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) declare function validateAndClone(obj: { readonly [P in keyof T]?: T[P] }): T; ->validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 107, 69)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 108, 37)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 108, 54)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 108, 54)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) +>validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 106, 69)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 107, 37)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 54)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 54)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) type Foo = { ->Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 108, 81)) +>Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 107, 81)) a?: number; ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 110, 12)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 109, 12)) readonly b: string; ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 111, 15)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 110, 15)) } function f10(foo: Foo) { ->f10 : Symbol(f10, Decl(isomorphicMappedTypeInference.ts, 113, 1)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) ->Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 108, 81)) +>f10 : Symbol(f10, Decl(isomorphicMappedTypeInference.ts, 112, 1)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) +>Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 107, 81)) let x = validate(foo); // { a: number, readonly b: string } ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 116, 7)) ->validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 104, 1)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 115, 7)) +>validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 103, 1)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) let y = clone(foo); // { a?: number, b: string } ->y : Symbol(y, Decl(isomorphicMappedTypeInference.ts, 117, 7)) ->clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 106, 64)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) +>y : Symbol(y, Decl(isomorphicMappedTypeInference.ts, 116, 7)) +>clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 105, 64)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) let z = validateAndClone(foo); // { a: number, b: string } ->z : Symbol(z, Decl(isomorphicMappedTypeInference.ts, 118, 7)) ->validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 107, 69)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) +>z : Symbol(z, Decl(isomorphicMappedTypeInference.ts, 117, 7)) +>validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 106, 69)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) } // Repro from #12606 type Func = (...args: any[]) => T; ->Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 119, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) ->args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 123, 16)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 118, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 122, 10)) +>args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 122, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 122, 10)) type Spec = { ->Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 123, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) +>Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 122, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) [P in keyof T]: Func | Spec ; ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 125, 5)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) ->Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 119, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 125, 5)) ->Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 123, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 125, 5)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 124, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 118, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 124, 5)) +>Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 122, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 124, 5)) }; @@ -424,66 +423,66 @@ type Spec = { * of calling its associated function with the supplied arguments. */ declare function applySpec(obj: Spec): (...args: any[]) => T; ->applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 126, 2)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 133, 27)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 133, 30)) ->Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 123, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 133, 27)) ->args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 133, 46)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 133, 27)) +>applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 125, 2)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 132, 27)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 132, 30)) +>Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 122, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 132, 27)) +>args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 132, 46)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 132, 27)) // Infers g1: (...args: any[]) => { sum: number, nested: { mul: string } } var g1 = applySpec({ ->g1 : Symbol(g1, Decl(isomorphicMappedTypeInference.ts, 136, 3)) ->applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 126, 2)) +>g1 : Symbol(g1, Decl(isomorphicMappedTypeInference.ts, 135, 3)) +>applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 125, 2)) sum: (a: any) => 3, ->sum : Symbol(sum, Decl(isomorphicMappedTypeInference.ts, 136, 20)) ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 137, 10)) +>sum : Symbol(sum, Decl(isomorphicMappedTypeInference.ts, 135, 20)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 136, 10)) nested: { ->nested : Symbol(nested, Decl(isomorphicMappedTypeInference.ts, 137, 23)) +>nested : Symbol(nested, Decl(isomorphicMappedTypeInference.ts, 136, 23)) mul: (b: any) => "n" ->mul : Symbol(mul, Decl(isomorphicMappedTypeInference.ts, 138, 13)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 139, 14)) +>mul : Symbol(mul, Decl(isomorphicMappedTypeInference.ts, 137, 13)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 138, 14)) } }); // Infers g2: (...args: any[]) => { foo: { bar: { baz: boolean } } } var g2 = applySpec({ foo: { bar: { baz: (x: any) => true } } }); ->g2 : Symbol(g2, Decl(isomorphicMappedTypeInference.ts, 144, 3)) ->applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 126, 2)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 144, 20)) ->bar : Symbol(bar, Decl(isomorphicMappedTypeInference.ts, 144, 27)) ->baz : Symbol(baz, Decl(isomorphicMappedTypeInference.ts, 144, 34)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 144, 41)) +>g2 : Symbol(g2, Decl(isomorphicMappedTypeInference.ts, 143, 3)) +>applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 125, 2)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 143, 20)) +>bar : Symbol(bar, Decl(isomorphicMappedTypeInference.ts, 143, 27)) +>baz : Symbol(baz, Decl(isomorphicMappedTypeInference.ts, 143, 34)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 143, 41)) // Repro from #12633 const foo = (object: T, partial: Partial) => object; ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 148, 5)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 148, 13)) ->object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 148, 16)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 148, 13)) ->partial : Symbol(partial, Decl(isomorphicMappedTypeInference.ts, 148, 26)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 147, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 147, 13)) +>object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 147, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 147, 13)) +>partial : Symbol(partial, Decl(isomorphicMappedTypeInference.ts, 147, 26)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 148, 13)) ->object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 148, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 147, 13)) +>object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 147, 16)) let o = {a: 5, b: 7}; ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 149, 9)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 149, 14)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 148, 9)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 148, 14)) foo(o, {b: 9}); ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 148, 5)) ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 150, 8)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 147, 5)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 149, 8)) o = foo(o, {b: 9}); ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 148, 5)) ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 151, 12)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 147, 5)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 150, 12)) diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.types b/tests/baselines/reference/isomorphicMappedTypeInference.types index ca20e06e113..c3414f46017 100644 --- a/tests/baselines/reference/isomorphicMappedTypeInference.types +++ b/tests/baselines/reference/isomorphicMappedTypeInference.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/isomorphicMappedTypeInference.ts === - type Box = { >Box : Box >T : T diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.js b/tests/baselines/reference/iteratorsAndStrictNullChecks.js index 97007917de5..23520a674d5 100644 --- a/tests/baselines/reference/iteratorsAndStrictNullChecks.js +++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.js @@ -1,5 +1,4 @@ //// [iteratorsAndStrictNullChecks.ts] - // for..of for (const x of ["a", "b"]) { x.substring; diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols b/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols index 8201a845a0f..fb75206a825 100644 --- a/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols +++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/iteratorsAndStrictNullChecks.ts === - // for..of for (const x of ["a", "b"]) { ->x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 2, 10)) +>x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 1, 10)) x.substring; >x.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 2, 10)) +>x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 1, 10)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } // Spread const xs = [1, 2, 3]; ->xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) +>xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 6, 5)) const ys = [4, 5]; ->ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 8, 5)) +>ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) xs.push(...ys); >xs.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) +>xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 6, 5)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 8, 5)) +>ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.types b/tests/baselines/reference/iteratorsAndStrictNullChecks.types index 43efed86ed4..efb5c1f97f2 100644 --- a/tests/baselines/reference/iteratorsAndStrictNullChecks.types +++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.types @@ -1,5 +1,4 @@ === tests/cases/compiler/iteratorsAndStrictNullChecks.ts === - // for..of for (const x of ["a", "b"]) { >x : string diff --git a/tests/baselines/reference/jsFileClassPropertyType.errors.txt b/tests/baselines/reference/jsFileClassPropertyType.errors.txt index f3767175710..72d11da9778 100644 --- a/tests/baselines/reference/jsFileClassPropertyType.errors.txt +++ b/tests/baselines/reference/jsFileClassPropertyType.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignable to type 'number'. +tests/cases/compiler/bar.ts(1,1): error TS2322: Type '"string"' is not assignable to type 'number'. ==== tests/cases/compiler/foo.js (0 errors) ==== - class C { constructor () { this.p = 0; @@ -10,7 +9,6 @@ tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignabl } ==== tests/cases/compiler/bar.ts (1 errors) ==== - (new C()).p = "string"; ~~~~~~~~~~~ !!! error TS2322: Type '"string"' is not assignable to type 'number'. diff --git a/tests/baselines/reference/jsFileClassPropertyType2.errors.txt b/tests/baselines/reference/jsFileClassPropertyType2.errors.txt index d0d138f7f48..e033ed3874e 100644 --- a/tests/baselines/reference/jsFileClassPropertyType2.errors.txt +++ b/tests/baselines/reference/jsFileClassPropertyType2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/bar.ts(2,18): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'. +tests/cases/compiler/bar.ts(1,18): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'. ==== tests/cases/compiler/foo.js (0 errors) ==== - class C { constructor() { /** @type {number[]}*/ @@ -11,7 +10,6 @@ tests/cases/compiler/bar.ts(2,18): error TS2345: Argument of type '"string"' is } ==== tests/cases/compiler/bar.ts (1 errors) ==== - (new C()).p.push("string"); ~~~~~~~~ !!! error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'. diff --git a/tests/baselines/reference/jsFileClassPropertyType3.errors.txt b/tests/baselines/reference/jsFileClassPropertyType3.errors.txt index bf225095b01..1035d92ea1b 100644 --- a/tests/baselines/reference/jsFileClassPropertyType3.errors.txt +++ b/tests/baselines/reference/jsFileClassPropertyType3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignable to type 'number'. +tests/cases/compiler/bar.ts(1,1): error TS2322: Type '"string"' is not assignable to type 'number'. ==== tests/cases/compiler/foo.js (0 errors) ==== - class C { constructor() { if (cond) { @@ -15,7 +14,6 @@ tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignabl } ==== tests/cases/compiler/bar.ts (1 errors) ==== - (new C()).p = "string"; // Error ~~~~~~~~~~~ !!! error TS2322: Type '"string"' is not assignable to type 'number'. diff --git a/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols b/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols index 2d9626897bf..a6d078dbf74 100644 --- a/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols +++ b/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/foo.js === - export class StackOverflowTest { >StackOverflowTest : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) constructor () { this.testStackOverflow = this.testStackOverflow.bind(this) ->this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) +>this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) >this : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) ->testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) ->this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) +>testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) +>this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) >this : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) ->testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) +>testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) >this : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) } } diff --git a/tests/baselines/reference/jsFileClassSelfReferencedProperty.types b/tests/baselines/reference/jsFileClassSelfReferencedProperty.types index 44344ac1472..204eee67c97 100644 --- a/tests/baselines/reference/jsFileClassSelfReferencedProperty.types +++ b/tests/baselines/reference/jsFileClassSelfReferencedProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.js === - export class StackOverflowTest { >StackOverflowTest : StackOverflowTest diff --git a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js index 32b10dafad3..0e7ff45f16c 100644 --- a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js +++ b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js @@ -1,5 +1,4 @@ //// [a.js] - class c { method(a) { let x = a => this.method(a); diff --git a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols index 0f6ba844290..a927a2a2ecb 100644 --- a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols +++ b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/a.js === - class c { >c : Symbol(c, Decl(a.js, 0, 0)) method(a) { ->method : Symbol(c.method, Decl(a.js, 1, 9)) ->a : Symbol(a, Decl(a.js, 2, 11)) +>method : Symbol(c.method, Decl(a.js, 0, 9)) +>a : Symbol(a, Decl(a.js, 1, 11)) let x = a => this.method(a); ->x : Symbol(x, Decl(a.js, 3, 11)) ->a : Symbol(a, Decl(a.js, 3, 15)) ->this.method : Symbol(c.method, Decl(a.js, 1, 9)) +>x : Symbol(x, Decl(a.js, 2, 11)) +>a : Symbol(a, Decl(a.js, 2, 15)) +>this.method : Symbol(c.method, Decl(a.js, 0, 9)) >this : Symbol(c, Decl(a.js, 0, 0)) ->method : Symbol(c.method, Decl(a.js, 1, 9)) ->a : Symbol(a, Decl(a.js, 3, 15)) +>method : Symbol(c.method, Decl(a.js, 0, 9)) +>a : Symbol(a, Decl(a.js, 2, 15)) } } diff --git a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types index f429cc88516..5ad6841b778 100644 --- a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types +++ b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - class c { >c : c diff --git a/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols b/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols index fcb678c3e6c..7663b2fcedf 100644 --- a/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols +++ b/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/moduleA/a.js === - import {a} from "b"; ->a : Symbol(a, Decl(a.js, 1, 8)) +>a : Symbol(a, Decl(a.js, 0, 8)) a++; ->a : Symbol(a, Decl(a.js, 1, 8)) +>a : Symbol(a, Decl(a.js, 0, 8)) import {c} from "c"; ->c : Symbol(c, Decl(a.js, 3, 8)) +>c : Symbol(c, Decl(a.js, 2, 8)) c++; ->c : Symbol(c, Decl(a.js, 3, 8)) +>c : Symbol(c, Decl(a.js, 2, 8)) === tests/cases/compiler/node_modules/b.ts === var a = 10; diff --git a/tests/baselines/reference/jsFileCompilationExternalPackageError.types b/tests/baselines/reference/jsFileCompilationExternalPackageError.types index d3a696d7bfe..c41a24fcffd 100644 --- a/tests/baselines/reference/jsFileCompilationExternalPackageError.types +++ b/tests/baselines/reference/jsFileCompilationExternalPackageError.types @@ -1,5 +1,4 @@ === tests/cases/compiler/moduleA/a.js === - import {a} from "b"; >a : any diff --git a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js index a87dad3c914..bf3baf3de37 100644 --- a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js +++ b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js @@ -1,5 +1,4 @@ //// [a.js] - function foo(a) { for (let a = 0; a < 10; a++) { // do something diff --git a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols index 6b0934c6591..5c260013632 100644 --- a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols +++ b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/a.js === - function foo(a) { >foo : Symbol(foo, Decl(a.js, 0, 0)) ->a : Symbol(a, Decl(a.js, 1, 13)) +>a : Symbol(a, Decl(a.js, 0, 13)) for (let a = 0; a < 10; a++) { ->a : Symbol(a, Decl(a.js, 2, 12)) ->a : Symbol(a, Decl(a.js, 2, 12)) ->a : Symbol(a, Decl(a.js, 2, 12)) +>a : Symbol(a, Decl(a.js, 1, 12)) +>a : Symbol(a, Decl(a.js, 1, 12)) +>a : Symbol(a, Decl(a.js, 1, 12)) // do something } diff --git a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types index 3cac906f5d7..15fa6c51087 100644 --- a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types +++ b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - function foo(a) { >foo : (a: any) => void >a : any diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js index 088b40e97ad..acc590418e9 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js @@ -1,5 +1,4 @@ //// [_apply.js] - /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols index f21653d475b..e7589f6ce55 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/_apply.js === - /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. @@ -12,55 +11,55 @@ */ function apply(func, thisArg, args) { >apply : Symbol(apply, Decl(_apply.js, 0, 0)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) var length = args.length; ->length : Symbol(length, Decl(_apply.js, 12, 7)) +>length : Symbol(length, Decl(_apply.js, 11, 7)) >args.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) switch (length) { ->length : Symbol(length, Decl(_apply.js, 12, 7)) +>length : Symbol(length, Decl(_apply.js, 11, 7)) case 0: return func.call(thisArg); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) case 1: return func.call(thisArg, args[0]); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) case 2: return func.call(thisArg, args[0], args[1]); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) case 3: return func.call(thisArg, args[0], args[1], args[2]); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) } return func.apply(thisArg, args); >func.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) } export default apply; diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types index c420454b8cf..54bc7938689 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/_apply.js === - /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. diff --git a/tests/baselines/reference/jsFileCompilationShortHandProperty.js b/tests/baselines/reference/jsFileCompilationShortHandProperty.js index 1dc269146a6..7d3cab85f4d 100644 --- a/tests/baselines/reference/jsFileCompilationShortHandProperty.js +++ b/tests/baselines/reference/jsFileCompilationShortHandProperty.js @@ -1,5 +1,4 @@ //// [a.js] - function foo() { var a = 10; var b = "Hello"; diff --git a/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols b/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols index fb42d121c80..be2502e0f22 100644 --- a/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols +++ b/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/a.js === - function foo() { >foo : Symbol(foo, Decl(a.js, 0, 0)) var a = 10; ->a : Symbol(a, Decl(a.js, 2, 7)) +>a : Symbol(a, Decl(a.js, 1, 7)) var b = "Hello"; ->b : Symbol(b, Decl(a.js, 3, 7)) +>b : Symbol(b, Decl(a.js, 2, 7)) return { a, ->a : Symbol(a, Decl(a.js, 4, 12)) +>a : Symbol(a, Decl(a.js, 3, 12)) b ->b : Symbol(b, Decl(a.js, 5, 10)) +>b : Symbol(b, Decl(a.js, 4, 10)) }; } diff --git a/tests/baselines/reference/jsFileCompilationShortHandProperty.types b/tests/baselines/reference/jsFileCompilationShortHandProperty.types index d6badf44909..0cb700b20f5 100644 --- a/tests/baselines/reference/jsFileCompilationShortHandProperty.types +++ b/tests/baselines/reference/jsFileCompilationShortHandProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - function foo() { >foo : () => { a: number; b: string; } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt index 84dfd78e6a3..f9d88bd2727 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt @@ -7,7 +7,6 @@ error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. Th !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. !!! error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.js', '.jsx'. ==== tests/cases/compiler/a.ts (0 errors) ==== - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js index 8e70b464c2f..6f2eaeb7379 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsFileCompilationWithMapFileAsJs.ts] //// //// [a.ts] - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map index d56cd75b1c2..5c7c4536a16 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map @@ -1,2 +1,2 @@ //// [a.js.map] -{"version":3,"file":"a.js","sourceRoot":"","sources":["a.ts"],"names":[],"mappings":"AACA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file +{"version":3,"file":"a.js","sourceRoot":"","sources":["a.ts"],"names":[],"mappings":"AAAA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt index d8c66a888b3..01e73159641 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:a.ts >>>var c = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function c() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -28,16 +27,16 @@ sourceFile:a.ts 1->class c { > 2 > } -1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(3, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(2, 2) + SourceIndex(0) --- >>> return c; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(4, 13) Source(3, 2) + SourceIndex(0) +1->Emitted(4, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(4, 13) Source(2, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -50,9 +49,9 @@ sourceFile:a.ts 3 > 4 > class c { > } -1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(3, 2) + SourceIndex(0) +1 >Emitted(5, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(5, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=a.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt index 84dfd78e6a3..f9d88bd2727 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt @@ -7,7 +7,6 @@ error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. Th !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. !!! error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.js', '.jsx'. ==== tests/cases/compiler/a.ts (0 errors) ==== - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js index c23d44b9cb8..e95bfbffaec 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.ts] //// //// [a.ts] - class c { } @@ -19,4 +18,4 @@ var c = (function () { } return c; }()); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt index c7cb8afe696..6a0ac0aac3a 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: a.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== sourceRoot: sources: a.ts =================================================================== @@ -11,15 +11,14 @@ sourceFile:a.ts >>>var c = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function c() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -28,16 +27,16 @@ sourceFile:a.ts 1->class c { > 2 > } -1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(3, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(2, 2) + SourceIndex(0) --- >>> return c; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(4, 13) Source(3, 2) + SourceIndex(0) +1->Emitted(4, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(4, 13) Source(2, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -50,9 +49,9 @@ sourceFile:a.ts 3 > 4 > class c { > } -1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(3, 2) + SourceIndex(0) +1 >Emitted(5, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(5, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt index c9a4408f423..2cdbe8c58f7 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt @@ -5,7 +5,6 @@ error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. Th !!! error TS6054: File 'tests/cases/compiler/b.js' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts'. !!! error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts'. ==== tests/cases/compiler/a.ts (0 errors) ==== - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js index b6c7efa9478..e098aaaa1c9 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithOutDir.ts] //// //// [a.ts] - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map index 4b90f5d778c..c4a4eda35e2 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map @@ -1,2 +1,2 @@ //// [a.js.map] -{"version":3,"file":"a.js","sourceRoot":"","sources":["../tests/cases/compiler/a.ts"],"names":[],"mappings":"AACA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file +{"version":3,"file":"a.js","sourceRoot":"","sources":["../tests/cases/compiler/a.ts"],"names":[],"mappings":"AAAA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt index 5c37dd75409..cee611eb9e8 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:../tests/cases/compiler/a.ts >>>var c = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function c() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -28,16 +27,16 @@ sourceFile:../tests/cases/compiler/a.ts 1->class c { > 2 > } -1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(3, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(2, 2) + SourceIndex(0) --- >>> return c; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(4, 13) Source(3, 2) + SourceIndex(0) +1->Emitted(4, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(4, 13) Source(2, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -50,9 +49,9 @@ sourceFile:../tests/cases/compiler/a.ts 3 > 4 > class c { > } -1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(3, 2) + SourceIndex(0) +1 >Emitted(5, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(5, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=a.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols b/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols index 040b910f378..17a6b60ebae 100644 --- a/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols +++ b/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/foo.js === - function f(a, b, c) { } >f : Symbol(f, Decl(foo.js, 0, 0)) ->a : Symbol(a, Decl(foo.js, 1, 11)) ->b : Symbol(b, Decl(foo.js, 1, 13)) ->c : Symbol(c, Decl(foo.js, 1, 16)) +>a : Symbol(a, Decl(foo.js, 0, 11)) +>b : Symbol(b, Decl(foo.js, 0, 13)) +>c : Symbol(c, Decl(foo.js, 0, 16)) === tests/cases/compiler/bar.ts === diff --git a/tests/baselines/reference/jsFileFunctionParametersAsOptional.types b/tests/baselines/reference/jsFileFunctionParametersAsOptional.types index d6d8f9b04a4..3260f6fdab7 100644 --- a/tests/baselines/reference/jsFileFunctionParametersAsOptional.types +++ b/tests/baselines/reference/jsFileFunctionParametersAsOptional.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.js === - function f(a, b, c) { } >f : (a: any, b: any, c: any) => void >a : any diff --git a/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt b/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt index 26ada935eea..236827b97bc 100644 --- a/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt +++ b/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt @@ -4,7 +4,6 @@ tests/cases/compiler/bar.ts(3,1): error TS2346: Supplied parameters do not match ==== tests/cases/compiler/foo.js (0 errors) ==== - /** * @param a * @param b diff --git a/tests/baselines/reference/json.stringify.js b/tests/baselines/reference/json.stringify.js index 8dba6a892af..a37485bdfa2 100644 --- a/tests/baselines/reference/json.stringify.js +++ b/tests/baselines/reference/json.stringify.js @@ -1,5 +1,4 @@ //// [json.stringify.ts] - var value = null; JSON.stringify(value, undefined, 2); JSON.stringify(value, null, 2); diff --git a/tests/baselines/reference/json.stringify.symbols b/tests/baselines/reference/json.stringify.symbols index 3c3c20ef30a..98afda4c6e7 100644 --- a/tests/baselines/reference/json.stringify.symbols +++ b/tests/baselines/reference/json.stringify.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/json.stringify.ts === - var value = null; ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) JSON.stringify(value, undefined, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) >undefined : Symbol(undefined) JSON.stringify(value, null, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) JSON.stringify(value, ["a", 1], 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) JSON.stringify(value, (k) => undefined, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) ->k : Symbol(k, Decl(json.stringify.ts, 5, 23)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) +>k : Symbol(k, Decl(json.stringify.ts, 4, 23)) >undefined : Symbol(undefined) JSON.stringify(value, undefined, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/json.stringify.types b/tests/baselines/reference/json.stringify.types index b063b06d8d0..a25eac5aaf7 100644 --- a/tests/baselines/reference/json.stringify.types +++ b/tests/baselines/reference/json.stringify.types @@ -1,5 +1,4 @@ === tests/cases/compiler/json.stringify.ts === - var value = null; >value : null >null : null diff --git a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt index d0e9bcf145b..5aa92086c37 100644 --- a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt +++ b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt @@ -1,21 +1,20 @@ -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,6): error TS17008: JSX element 'any' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,13): error TS2304: Cannot find name 'test'. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,17): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(9,6): error TS17008: JSX element 'any' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,6): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,32): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,36): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,17): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,45): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,2): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,8): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,13): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS1005: ':' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS1005: ' ~~~~ diff --git a/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js b/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js index f07cbabd7f8..3603c7989b8 100644 --- a/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js +++ b/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js @@ -1,5 +1,4 @@ //// [jsxAttributeWithoutExpressionReact.tsx] - declare var React: any; diff --git a/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols b/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols index a5f910776b0..27cdac0100b 100644 --- a/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols +++ b/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/jsxEmitAttributeWithPreserve.tsx === - declare var React: any; ->React : Symbol(React, Decl(jsxEmitAttributeWithPreserve.tsx, 1, 11)) +>React : Symbol(React, Decl(jsxEmitAttributeWithPreserve.tsx, 0, 11)) >foo : Symbol(unknown) ->data : Symbol(data, Decl(jsxEmitAttributeWithPreserve.tsx, 2, 4)) +>data : Symbol(data, Decl(jsxEmitAttributeWithPreserve.tsx, 1, 4)) diff --git a/tests/baselines/reference/jsxEmitAttributeWithPreserve.types b/tests/baselines/reference/jsxEmitAttributeWithPreserve.types index 7d218f422bf..1f6cc13bd08 100644 --- a/tests/baselines/reference/jsxEmitAttributeWithPreserve.types +++ b/tests/baselines/reference/jsxEmitAttributeWithPreserve.types @@ -1,5 +1,4 @@ === tests/cases/compiler/jsxEmitAttributeWithPreserve.tsx === - declare var React: any; >React : any diff --git a/tests/baselines/reference/jsxEmitWithAttributes.js b/tests/baselines/reference/jsxEmitWithAttributes.js index dd4d326268b..f92ee5acb33 100644 --- a/tests/baselines/reference/jsxEmitWithAttributes.js +++ b/tests/baselines/reference/jsxEmitWithAttributes.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxEmitWithAttributes.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxEmitWithAttributes.symbols b/tests/baselines/reference/jsxEmitWithAttributes.symbols index f2579903d3e..f20470ebb6b 100644 --- a/tests/baselines/reference/jsxEmitWithAttributes.symbols +++ b/tests/baselines/reference/jsxEmitWithAttributes.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) interface Element { ->Element : Symbol(Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(Element, Decl(Element.ts, 0, 23)) name: string; ->name : Symbol(Element.name, Decl(Element.ts, 2, 23)) +>name : Symbol(Element.name, Decl(Element.ts, 1, 23)) isIntrinsic: boolean; ->isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 3, 21)) +>isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 2, 21)) isCustomElement: boolean; ->isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 4, 29)) +>isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 3, 29)) toString(renderId?: number): string; ->toString : Symbol(Element.toString, Decl(Element.ts, 5, 33)) ->renderId : Symbol(renderId, Decl(Element.ts, 6, 17)) +>toString : Symbol(Element.toString, Decl(Element.ts, 4, 33)) +>renderId : Symbol(renderId, Decl(Element.ts, 5, 17)) bindDOM(renderId?: number): number; ->bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 6, 44)) ->renderId : Symbol(renderId, Decl(Element.ts, 7, 16)) +>bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 5, 44)) +>renderId : Symbol(renderId, Decl(Element.ts, 6, 16)) resetComponent(): void; ->resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 7, 43)) +>resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 6, 43)) instantiateComponents(renderId?: number): number; ->instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 8, 31)) ->renderId : Symbol(renderId, Decl(Element.ts, 9, 30)) +>instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 7, 31)) +>renderId : Symbol(renderId, Decl(Element.ts, 8, 30)) props: any; ->props : Symbol(Element.props, Decl(Element.ts, 9, 57)) +>props : Symbol(Element.props, Decl(Element.ts, 8, 57)) } } export namespace Element { ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) export function isElement(el: any): el is JSX.Element { ->isElement : Symbol(isElement, Decl(Element.ts, 13, 26)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>isElement : Symbol(isElement, Decl(Element.ts, 12, 26)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) ->Element : Symbol(JSX.Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(JSX.Element, Decl(Element.ts, 0, 23)) return el.markAsChildOfRootElement !== undefined; ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >undefined : Symbol(undefined) } export function createElement(args: any[]) { ->createElement : Symbol(createElement, Decl(Element.ts, 16, 5)) ->args : Symbol(args, Decl(Element.ts, 18, 34)) +>createElement : Symbol(createElement, Decl(Element.ts, 15, 5)) +>args : Symbol(args, Decl(Element.ts, 17, 34)) return { } @@ -59,21 +58,21 @@ export namespace Element { } export let createElement = Element.createElement; ->createElement : Symbol(createElement, Decl(Element.ts, 25, 10)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(createElement, Decl(Element.ts, 24, 10)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) function toCamelCase(text: string): string { ->toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 25, 49)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 24, 49)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) return text[0].toLowerCase() + text.substring(1); >text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) >text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } diff --git a/tests/baselines/reference/jsxEmitWithAttributes.types b/tests/baselines/reference/jsxEmitWithAttributes.types index 724aed319ec..044b65222a9 100644 --- a/tests/baselines/reference/jsxEmitWithAttributes.types +++ b/tests/baselines/reference/jsxEmitWithAttributes.types @@ -1,5 +1,4 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt b/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt index c4859fd534c..c1734f6304c 100644 --- a/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt +++ b/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt @@ -3,7 +3,6 @@ error TS5053: Option 'reactNamespace' cannot be specified with option 'jsxFactor !!! error TS5053: Option 'reactNamespace' cannot be specified with option 'jsxFactory'. ==== tests/cases/compiler/Element.ts (0 errors) ==== - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryAndReactNamespace.js b/tests/baselines/reference/jsxFactoryAndReactNamespace.js index a864da65dbb..277a74a8c2f 100644 --- a/tests/baselines/reference/jsxFactoryAndReactNamespace.js +++ b/tests/baselines/reference/jsxFactoryAndReactNamespace.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryAndReactNamespace.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryIdentifier.js b/tests/baselines/reference/jsxFactoryIdentifier.js index 9beff01d707..3a3c360a8f1 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.js +++ b/tests/baselines/reference/jsxFactoryIdentifier.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryIdentifier.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryIdentifier.js.map b/tests/baselines/reference/jsxFactoryIdentifier.js.map index 57ff760b8a8..ab23c9b10b3 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.js.map +++ b/tests/baselines/reference/jsxFactoryIdentifier.js.map @@ -1,3 +1,3 @@ //// [Element.js.map] -{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAaA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] +{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAYA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] {"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAAA,uCAAmC;AACnC,IAAI,aAAa,GAAG,iBAAO,CAAC,aAAa,CAAC;AAC1C,IAAI,CAIH,CAAC;AAEF;IACC,IAAI;QACH,MAAM,CAAC;YACN,wBAAM,OAAO,EAAC,YAAY,GAAQ;YAClC,wBAAM,OAAO,EAAE,CAAC,CAAC,CAAE,CAAC,CAAC,GAAS;SAC9B,CAAC;IACH,CAAC;CACD"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt b/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt index 6101ee1d5e7..c0359aa61d0 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt @@ -16,8 +16,7 @@ sourceFile:Element.ts 3 > ^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >declare namespace JSX { +1 >declare namespace JSX { > interface Element { > name: string; > isIntrinsic: boolean; @@ -43,10 +42,10 @@ sourceFile:Element.ts > } > } > } -1 >Emitted(3, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(3, 5) Source(14, 18) + SourceIndex(0) -3 >Emitted(3, 12) Source(14, 25) + SourceIndex(0) -4 >Emitted(3, 13) Source(24, 2) + SourceIndex(0) +1 >Emitted(3, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(3, 5) Source(13, 18) + SourceIndex(0) +3 >Emitted(3, 12) Source(13, 25) + SourceIndex(0) +4 >Emitted(3, 13) Source(23, 2) + SourceIndex(0) --- >>>(function (Element) { 1-> @@ -56,9 +55,9 @@ sourceFile:Element.ts 1-> 2 >export namespace 3 > Element -1->Emitted(4, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(4, 12) Source(14, 18) + SourceIndex(0) -3 >Emitted(4, 19) Source(14, 25) + SourceIndex(0) +1->Emitted(4, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(4, 12) Source(13, 18) + SourceIndex(0) +3 >Emitted(4, 19) Source(13, 25) + SourceIndex(0) --- >>> function isElement(el) { 1->^^^^ @@ -69,9 +68,9 @@ sourceFile:Element.ts > 2 > export function isElement( 3 > el: any -1->Emitted(5, 5) Source(15, 5) + SourceIndex(0) -2 >Emitted(5, 24) Source(15, 31) + SourceIndex(0) -3 >Emitted(5, 26) Source(15, 38) + SourceIndex(0) +1->Emitted(5, 5) Source(14, 5) + SourceIndex(0) +2 >Emitted(5, 24) Source(14, 31) + SourceIndex(0) +3 >Emitted(5, 26) Source(14, 38) + SourceIndex(0) --- >>> return el.markAsChildOfRootElement !== undefined; 1->^^^^^^^^ @@ -93,15 +92,15 @@ sourceFile:Element.ts 7 > !== 8 > undefined 9 > ; -1->Emitted(6, 9) Source(16, 9) + SourceIndex(0) -2 >Emitted(6, 15) Source(16, 15) + SourceIndex(0) -3 >Emitted(6, 16) Source(16, 16) + SourceIndex(0) -4 >Emitted(6, 18) Source(16, 18) + SourceIndex(0) -5 >Emitted(6, 19) Source(16, 19) + SourceIndex(0) -6 >Emitted(6, 43) Source(16, 43) + SourceIndex(0) -7 >Emitted(6, 48) Source(16, 48) + SourceIndex(0) -8 >Emitted(6, 57) Source(16, 57) + SourceIndex(0) -9 >Emitted(6, 58) Source(16, 58) + SourceIndex(0) +1->Emitted(6, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(6, 15) Source(15, 15) + SourceIndex(0) +3 >Emitted(6, 16) Source(15, 16) + SourceIndex(0) +4 >Emitted(6, 18) Source(15, 18) + SourceIndex(0) +5 >Emitted(6, 19) Source(15, 19) + SourceIndex(0) +6 >Emitted(6, 43) Source(15, 43) + SourceIndex(0) +7 >Emitted(6, 48) Source(15, 48) + SourceIndex(0) +8 >Emitted(6, 57) Source(15, 57) + SourceIndex(0) +9 >Emitted(6, 58) Source(15, 58) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -110,8 +109,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(7, 5) Source(17, 5) + SourceIndex(0) -2 >Emitted(7, 6) Source(17, 6) + SourceIndex(0) +1 >Emitted(7, 5) Source(16, 5) + SourceIndex(0) +2 >Emitted(7, 6) Source(16, 6) + SourceIndex(0) --- >>> Element.isElement = isElement; 1->^^^^ @@ -125,10 +124,10 @@ sourceFile:Element.ts > return el.markAsChildOfRootElement !== undefined; > } 4 > -1->Emitted(8, 5) Source(15, 21) + SourceIndex(0) -2 >Emitted(8, 22) Source(15, 30) + SourceIndex(0) -3 >Emitted(8, 34) Source(17, 6) + SourceIndex(0) -4 >Emitted(8, 35) Source(17, 6) + SourceIndex(0) +1->Emitted(8, 5) Source(14, 21) + SourceIndex(0) +2 >Emitted(8, 22) Source(14, 30) + SourceIndex(0) +3 >Emitted(8, 34) Source(16, 6) + SourceIndex(0) +4 >Emitted(8, 35) Source(16, 6) + SourceIndex(0) --- >>> function createElement(args) { 1->^^^^ @@ -139,9 +138,9 @@ sourceFile:Element.ts > 2 > export function createElement( 3 > args: any[] -1->Emitted(9, 5) Source(19, 5) + SourceIndex(0) -2 >Emitted(9, 28) Source(19, 35) + SourceIndex(0) -3 >Emitted(9, 32) Source(19, 46) + SourceIndex(0) +1->Emitted(9, 5) Source(18, 5) + SourceIndex(0) +2 >Emitted(9, 28) Source(18, 35) + SourceIndex(0) +3 >Emitted(9, 32) Source(18, 46) + SourceIndex(0) --- >>> return {}; 1 >^^^^^^^^ @@ -157,11 +156,11 @@ sourceFile:Element.ts 4 > { > } 5 > -1 >Emitted(10, 9) Source(21, 9) + SourceIndex(0) -2 >Emitted(10, 15) Source(21, 15) + SourceIndex(0) -3 >Emitted(10, 16) Source(21, 16) + SourceIndex(0) -4 >Emitted(10, 18) Source(22, 10) + SourceIndex(0) -5 >Emitted(10, 19) Source(22, 10) + SourceIndex(0) +1 >Emitted(10, 9) Source(20, 9) + SourceIndex(0) +2 >Emitted(10, 15) Source(20, 15) + SourceIndex(0) +3 >Emitted(10, 16) Source(20, 16) + SourceIndex(0) +4 >Emitted(10, 18) Source(21, 10) + SourceIndex(0) +5 >Emitted(10, 19) Source(21, 10) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -170,8 +169,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(11, 5) Source(23, 5) + SourceIndex(0) -2 >Emitted(11, 6) Source(23, 6) + SourceIndex(0) +1 >Emitted(11, 5) Source(22, 5) + SourceIndex(0) +2 >Emitted(11, 6) Source(22, 6) + SourceIndex(0) --- >>> Element.createElement = createElement; 1->^^^^ @@ -187,10 +186,10 @@ sourceFile:Element.ts > } > } 4 > -1->Emitted(12, 5) Source(19, 21) + SourceIndex(0) -2 >Emitted(12, 26) Source(19, 34) + SourceIndex(0) -3 >Emitted(12, 42) Source(23, 6) + SourceIndex(0) -4 >Emitted(12, 43) Source(23, 6) + SourceIndex(0) +1->Emitted(12, 5) Source(18, 21) + SourceIndex(0) +2 >Emitted(12, 26) Source(18, 34) + SourceIndex(0) +3 >Emitted(12, 42) Source(22, 6) + SourceIndex(0) +4 >Emitted(12, 43) Source(22, 6) + SourceIndex(0) --- >>>})(Element = exports.Element || (exports.Element = {})); 1-> @@ -222,15 +221,15 @@ sourceFile:Element.ts > } > } > } -1->Emitted(13, 1) Source(24, 1) + SourceIndex(0) -2 >Emitted(13, 2) Source(24, 2) + SourceIndex(0) -3 >Emitted(13, 4) Source(14, 18) + SourceIndex(0) -4 >Emitted(13, 11) Source(14, 25) + SourceIndex(0) -5 >Emitted(13, 14) Source(14, 18) + SourceIndex(0) -6 >Emitted(13, 29) Source(14, 25) + SourceIndex(0) -7 >Emitted(13, 34) Source(14, 18) + SourceIndex(0) -8 >Emitted(13, 49) Source(14, 25) + SourceIndex(0) -9 >Emitted(13, 57) Source(24, 2) + SourceIndex(0) +1->Emitted(13, 1) Source(23, 1) + SourceIndex(0) +2 >Emitted(13, 2) Source(23, 2) + SourceIndex(0) +3 >Emitted(13, 4) Source(13, 18) + SourceIndex(0) +4 >Emitted(13, 11) Source(13, 25) + SourceIndex(0) +5 >Emitted(13, 14) Source(13, 18) + SourceIndex(0) +6 >Emitted(13, 29) Source(13, 25) + SourceIndex(0) +7 >Emitted(13, 34) Source(13, 18) + SourceIndex(0) +8 >Emitted(13, 49) Source(13, 25) + SourceIndex(0) +9 >Emitted(13, 57) Source(23, 2) + SourceIndex(0) --- >>>exports.createElement = Element.createElement; 1 > @@ -251,14 +250,14 @@ sourceFile:Element.ts 6 > . 7 > createElement 8 > ; -1 >Emitted(14, 1) Source(26, 12) + SourceIndex(0) -2 >Emitted(14, 9) Source(26, 12) + SourceIndex(0) -3 >Emitted(14, 22) Source(26, 25) + SourceIndex(0) -4 >Emitted(14, 25) Source(26, 28) + SourceIndex(0) -5 >Emitted(14, 32) Source(26, 35) + SourceIndex(0) -6 >Emitted(14, 33) Source(26, 36) + SourceIndex(0) -7 >Emitted(14, 46) Source(26, 49) + SourceIndex(0) -8 >Emitted(14, 47) Source(26, 50) + SourceIndex(0) +1 >Emitted(14, 1) Source(25, 12) + SourceIndex(0) +2 >Emitted(14, 9) Source(25, 12) + SourceIndex(0) +3 >Emitted(14, 22) Source(25, 25) + SourceIndex(0) +4 >Emitted(14, 25) Source(25, 28) + SourceIndex(0) +5 >Emitted(14, 32) Source(25, 35) + SourceIndex(0) +6 >Emitted(14, 33) Source(25, 36) + SourceIndex(0) +7 >Emitted(14, 46) Source(25, 49) + SourceIndex(0) +8 >Emitted(14, 47) Source(25, 50) + SourceIndex(0) --- >>>function toCamelCase(text) { 1 > @@ -270,9 +269,9 @@ sourceFile:Element.ts > 2 >function toCamelCase( 3 > text: string -1 >Emitted(15, 1) Source(28, 1) + SourceIndex(0) -2 >Emitted(15, 22) Source(28, 22) + SourceIndex(0) -3 >Emitted(15, 26) Source(28, 34) + SourceIndex(0) +1 >Emitted(15, 1) Source(27, 1) + SourceIndex(0) +2 >Emitted(15, 22) Source(27, 22) + SourceIndex(0) +3 >Emitted(15, 26) Source(27, 34) + SourceIndex(0) --- >>> return text[0].toLowerCase() + text.substring(1); 1->^^^^ @@ -312,24 +311,24 @@ sourceFile:Element.ts 16> 1 17> ) 18> ; -1->Emitted(16, 5) Source(29, 5) + SourceIndex(0) -2 >Emitted(16, 11) Source(29, 11) + SourceIndex(0) -3 >Emitted(16, 12) Source(29, 12) + SourceIndex(0) -4 >Emitted(16, 16) Source(29, 16) + SourceIndex(0) -5 >Emitted(16, 17) Source(29, 17) + SourceIndex(0) -6 >Emitted(16, 18) Source(29, 18) + SourceIndex(0) -7 >Emitted(16, 19) Source(29, 19) + SourceIndex(0) -8 >Emitted(16, 20) Source(29, 20) + SourceIndex(0) -9 >Emitted(16, 31) Source(29, 31) + SourceIndex(0) -10>Emitted(16, 33) Source(29, 33) + SourceIndex(0) -11>Emitted(16, 36) Source(29, 36) + SourceIndex(0) -12>Emitted(16, 40) Source(29, 40) + SourceIndex(0) -13>Emitted(16, 41) Source(29, 41) + SourceIndex(0) -14>Emitted(16, 50) Source(29, 50) + SourceIndex(0) -15>Emitted(16, 51) Source(29, 51) + SourceIndex(0) -16>Emitted(16, 52) Source(29, 52) + SourceIndex(0) -17>Emitted(16, 53) Source(29, 53) + SourceIndex(0) -18>Emitted(16, 54) Source(29, 54) + SourceIndex(0) +1->Emitted(16, 5) Source(28, 5) + SourceIndex(0) +2 >Emitted(16, 11) Source(28, 11) + SourceIndex(0) +3 >Emitted(16, 12) Source(28, 12) + SourceIndex(0) +4 >Emitted(16, 16) Source(28, 16) + SourceIndex(0) +5 >Emitted(16, 17) Source(28, 17) + SourceIndex(0) +6 >Emitted(16, 18) Source(28, 18) + SourceIndex(0) +7 >Emitted(16, 19) Source(28, 19) + SourceIndex(0) +8 >Emitted(16, 20) Source(28, 20) + SourceIndex(0) +9 >Emitted(16, 31) Source(28, 31) + SourceIndex(0) +10>Emitted(16, 33) Source(28, 33) + SourceIndex(0) +11>Emitted(16, 36) Source(28, 36) + SourceIndex(0) +12>Emitted(16, 40) Source(28, 40) + SourceIndex(0) +13>Emitted(16, 41) Source(28, 41) + SourceIndex(0) +14>Emitted(16, 50) Source(28, 50) + SourceIndex(0) +15>Emitted(16, 51) Source(28, 51) + SourceIndex(0) +16>Emitted(16, 52) Source(28, 52) + SourceIndex(0) +17>Emitted(16, 53) Source(28, 53) + SourceIndex(0) +18>Emitted(16, 54) Source(28, 54) + SourceIndex(0) --- >>>} 1 > @@ -338,8 +337,8 @@ sourceFile:Element.ts 1 > > 2 >} -1 >Emitted(17, 1) Source(30, 1) + SourceIndex(0) -2 >Emitted(17, 2) Source(30, 2) + SourceIndex(0) +1 >Emitted(17, 1) Source(29, 1) + SourceIndex(0) +2 >Emitted(17, 2) Source(29, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=Element.js.map=================================================================== JsFile: test.js diff --git a/tests/baselines/reference/jsxFactoryIdentifier.symbols b/tests/baselines/reference/jsxFactoryIdentifier.symbols index b6d6856bccb..b66976f8884 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.symbols +++ b/tests/baselines/reference/jsxFactoryIdentifier.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) interface Element { ->Element : Symbol(Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(Element, Decl(Element.ts, 0, 23)) name: string; ->name : Symbol(Element.name, Decl(Element.ts, 2, 23)) +>name : Symbol(Element.name, Decl(Element.ts, 1, 23)) isIntrinsic: boolean; ->isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 3, 21)) +>isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 2, 21)) isCustomElement: boolean; ->isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 4, 29)) +>isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 3, 29)) toString(renderId?: number): string; ->toString : Symbol(Element.toString, Decl(Element.ts, 5, 33)) ->renderId : Symbol(renderId, Decl(Element.ts, 6, 17)) +>toString : Symbol(Element.toString, Decl(Element.ts, 4, 33)) +>renderId : Symbol(renderId, Decl(Element.ts, 5, 17)) bindDOM(renderId?: number): number; ->bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 6, 44)) ->renderId : Symbol(renderId, Decl(Element.ts, 7, 16)) +>bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 5, 44)) +>renderId : Symbol(renderId, Decl(Element.ts, 6, 16)) resetComponent(): void; ->resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 7, 43)) +>resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 6, 43)) instantiateComponents(renderId?: number): number; ->instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 8, 31)) ->renderId : Symbol(renderId, Decl(Element.ts, 9, 30)) +>instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 7, 31)) +>renderId : Symbol(renderId, Decl(Element.ts, 8, 30)) props: any; ->props : Symbol(Element.props, Decl(Element.ts, 9, 57)) +>props : Symbol(Element.props, Decl(Element.ts, 8, 57)) } } export namespace Element { ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) export function isElement(el: any): el is JSX.Element { ->isElement : Symbol(isElement, Decl(Element.ts, 13, 26)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>isElement : Symbol(isElement, Decl(Element.ts, 12, 26)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) ->Element : Symbol(JSX.Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(JSX.Element, Decl(Element.ts, 0, 23)) return el.markAsChildOfRootElement !== undefined; ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >undefined : Symbol(undefined) } export function createElement(args: any[]) { ->createElement : Symbol(createElement, Decl(Element.ts, 16, 5)) ->args : Symbol(args, Decl(Element.ts, 18, 34)) +>createElement : Symbol(createElement, Decl(Element.ts, 15, 5)) +>args : Symbol(args, Decl(Element.ts, 17, 34)) return { } @@ -59,21 +58,21 @@ export namespace Element { } export let createElement = Element.createElement; ->createElement : Symbol(createElement, Decl(Element.ts, 25, 10)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(createElement, Decl(Element.ts, 24, 10)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) function toCamelCase(text: string): string { ->toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 25, 49)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 24, 49)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) return text[0].toLowerCase() + text.substring(1); >text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) >text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } @@ -83,9 +82,9 @@ import { Element} from './Element'; let createElement = Element.createElement; >createElement : Symbol(createElement, Decl(test.tsx, 1, 3)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) >Element : Symbol(Element, Decl(test.tsx, 0, 8)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) let c: { >c : Symbol(c, Decl(test.tsx, 2, 3)) diff --git a/tests/baselines/reference/jsxFactoryIdentifier.types b/tests/baselines/reference/jsxFactoryIdentifier.types index cb44bb0ac0f..76f49568531 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.types +++ b/tests/baselines/reference/jsxFactoryIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js index 05da89d0d85..f72748642bb 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map index c72e1bf8057..c0e44a28e3f 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map @@ -1,2 +1,2 @@ //// [test.js.map] -{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAOA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file +{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAMA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt index b2d30177b1d..b8836a65a1c 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt @@ -13,15 +13,14 @@ sourceFile:test.tsx >>>class AppComponent { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface IntrinsicElements { > [s: string]: any; > } >} > > -1 >Emitted(3, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(3, 1) Source(7, 1) + SourceIndex(0) --- >>> render(createElement) { 1->^^^^ @@ -34,10 +33,10 @@ sourceFile:test.tsx 2 > render 3 > ( 4 > createElement -1->Emitted(4, 5) Source(9, 5) + SourceIndex(0) -2 >Emitted(4, 11) Source(9, 11) + SourceIndex(0) -3 >Emitted(4, 12) Source(9, 12) + SourceIndex(0) -4 >Emitted(4, 25) Source(9, 25) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 5) + SourceIndex(0) +2 >Emitted(4, 11) Source(8, 11) + SourceIndex(0) +3 >Emitted(4, 12) Source(8, 12) + SourceIndex(0) +4 >Emitted(4, 25) Source(8, 25) + SourceIndex(0) --- >>> return createElement("div", null); 1->^^^^^^^^ @@ -51,11 +50,11 @@ sourceFile:test.tsx 3 > 4 >
5 > ; -1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) -4 >Emitted(5, 42) Source(10, 23) + SourceIndex(0) -5 >Emitted(5, 43) Source(10, 24) + SourceIndex(0) +1->Emitted(5, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(9, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(9, 16) + SourceIndex(0) +4 >Emitted(5, 42) Source(9, 23) + SourceIndex(0) +5 >Emitted(5, 43) Source(9, 24) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -63,15 +62,15 @@ sourceFile:test.tsx 1 > > 2 > } -1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(10, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(11, 2) + SourceIndex(0) --- >>>exports.AppComponent = AppComponent; 1-> @@ -82,7 +81,7 @@ sourceFile:test.tsx > return
; > } >} -1->Emitted(8, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(8, 37) Source(12, 2) + SourceIndex(0) +1->Emitted(8, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(8, 37) Source(11, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=test.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols index 865292092a5..069e377d47b 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/test.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(test.tsx, 0, 0)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(test.tsx, 1, 20)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(test.tsx, 0, 20)) [s: string]: any; ->s : Symbol(s, Decl(test.tsx, 3, 9)) +>s : Symbol(s, Decl(test.tsx, 2, 9)) } } export class AppComponent { ->AppComponent : Symbol(AppComponent, Decl(test.tsx, 5, 1)) +>AppComponent : Symbol(AppComponent, Decl(test.tsx, 4, 1)) render(createElement) { ->render : Symbol(AppComponent.render, Decl(test.tsx, 7, 27)) ->createElement : Symbol(createElement, Decl(test.tsx, 8, 11)) +>render : Symbol(AppComponent.render, Decl(test.tsx, 6, 27)) +>createElement : Symbol(createElement, Decl(test.tsx, 7, 11)) return
; >div : Symbol(unknown) diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types index d55737d98ae..e2fa620b4ac 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt index 99e039a045f..2b51171a6f1 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.tsx(10,17): error TS2304: Cannot find name 'createElement'. +tests/cases/compiler/test.tsx(9,17): error TS2304: Cannot find name 'createElement'. ==== tests/cases/compiler/test.tsx (1 errors) ==== - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js index c9f5f3465e3..8ae3a3842a7 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map index 66666a526d6..28e14ed6be5 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map @@ -1,2 +1,2 @@ //// [test.js.map] -{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAOA;IACI,MAAM;QACF,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file +{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAMA;IACI,MAAM;QACF,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt index 1a77ab3eae1..378b69deb69 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt @@ -13,15 +13,14 @@ sourceFile:test.tsx >>>class AppComponent { 1 > 2 >^^^^^^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface IntrinsicElements { > [s: string]: any; > } >} > > -1 >Emitted(3, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(3, 1) Source(7, 1) + SourceIndex(0) --- >>> render() { 1->^^^^ @@ -30,8 +29,8 @@ sourceFile:test.tsx 1->export class AppComponent { > 2 > render -1->Emitted(4, 5) Source(9, 5) + SourceIndex(0) -2 >Emitted(4, 11) Source(9, 11) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 5) + SourceIndex(0) +2 >Emitted(4, 11) Source(8, 11) + SourceIndex(0) --- >>> return createElement("div", null); 1->^^^^^^^^ @@ -45,11 +44,11 @@ sourceFile:test.tsx 3 > 4 >
5 > ; -1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) -4 >Emitted(5, 42) Source(10, 23) + SourceIndex(0) -5 >Emitted(5, 43) Source(10, 24) + SourceIndex(0) +1->Emitted(5, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(9, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(9, 16) + SourceIndex(0) +4 >Emitted(5, 42) Source(9, 23) + SourceIndex(0) +5 >Emitted(5, 43) Source(9, 24) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -57,15 +56,15 @@ sourceFile:test.tsx 1 > > 2 > } -1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(10, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(11, 2) + SourceIndex(0) --- >>>exports.AppComponent = AppComponent; 1-> @@ -76,7 +75,7 @@ sourceFile:test.tsx > return
; > } >} -1->Emitted(8, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(8, 37) Source(12, 2) + SourceIndex(0) +1->Emitted(8, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(8, 37) Source(11, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=test.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt index e14f5f988f8..c148a0b2658 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt @@ -5,7 +5,6 @@ tests/cases/compiler/test.tsx(13,5): error TS2304: Cannot find name 'React'. !!! error TS5067: Invalid value for 'jsxFactory'. 'Element.createElement=' is not a valid identifier or qualified-name. ==== tests/cases/compiler/Element.ts (0 errors) ==== - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js index 9fc5799b11d..8e4b1d8fc12 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryNotIdentifierOrQualifiedName.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt index 1c33f3a7a51..f0cf20e2e04 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt @@ -5,7 +5,6 @@ tests/cases/compiler/test.tsx(13,5): error TS2304: Cannot find name 'React'. !!! error TS5067: Invalid value for 'jsxFactory'. 'id1 id2' is not a valid identifier or qualified-name. ==== tests/cases/compiler/Element.ts (0 errors) ==== - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js index aa90c74cce5..6c7c95e36ff 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryNotIdentifierOrQualifiedName2.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.js b/tests/baselines/reference/jsxFactoryQualifiedName.js index ee747733799..63b45e878dd 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.js +++ b/tests/baselines/reference/jsxFactoryQualifiedName.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryQualifiedName.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.js.map b/tests/baselines/reference/jsxFactoryQualifiedName.js.map index 6c5dd8abf56..c4ac2d8e7e4 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.js.map +++ b/tests/baselines/reference/jsxFactoryQualifiedName.js.map @@ -1,3 +1,3 @@ //// [Element.js.map] -{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAaA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] +{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAYA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] {"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAAA,uCAAmC;AAEnC,IAAI,CAIH,CAAC;AAEF;IACC,IAAI;QACH,MAAM,CAAC;YACN,0CAAM,OAAO,EAAC,YAAY,GAAQ;YAClC,0CAAM,OAAO,EAAE,CAAC,CAAC,CAAE,CAAC,CAAC,GAAS;SAC9B,CAAC;IACH,CAAC;CACD"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt b/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt index 9831a9ab5fd..46a5945cc15 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt @@ -16,8 +16,7 @@ sourceFile:Element.ts 3 > ^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >declare namespace JSX { +1 >declare namespace JSX { > interface Element { > name: string; > isIntrinsic: boolean; @@ -43,10 +42,10 @@ sourceFile:Element.ts > } > } > } -1 >Emitted(3, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(3, 5) Source(14, 18) + SourceIndex(0) -3 >Emitted(3, 12) Source(14, 25) + SourceIndex(0) -4 >Emitted(3, 13) Source(24, 2) + SourceIndex(0) +1 >Emitted(3, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(3, 5) Source(13, 18) + SourceIndex(0) +3 >Emitted(3, 12) Source(13, 25) + SourceIndex(0) +4 >Emitted(3, 13) Source(23, 2) + SourceIndex(0) --- >>>(function (Element) { 1-> @@ -56,9 +55,9 @@ sourceFile:Element.ts 1-> 2 >export namespace 3 > Element -1->Emitted(4, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(4, 12) Source(14, 18) + SourceIndex(0) -3 >Emitted(4, 19) Source(14, 25) + SourceIndex(0) +1->Emitted(4, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(4, 12) Source(13, 18) + SourceIndex(0) +3 >Emitted(4, 19) Source(13, 25) + SourceIndex(0) --- >>> function isElement(el) { 1->^^^^ @@ -69,9 +68,9 @@ sourceFile:Element.ts > 2 > export function isElement( 3 > el: any -1->Emitted(5, 5) Source(15, 5) + SourceIndex(0) -2 >Emitted(5, 24) Source(15, 31) + SourceIndex(0) -3 >Emitted(5, 26) Source(15, 38) + SourceIndex(0) +1->Emitted(5, 5) Source(14, 5) + SourceIndex(0) +2 >Emitted(5, 24) Source(14, 31) + SourceIndex(0) +3 >Emitted(5, 26) Source(14, 38) + SourceIndex(0) --- >>> return el.markAsChildOfRootElement !== undefined; 1->^^^^^^^^ @@ -93,15 +92,15 @@ sourceFile:Element.ts 7 > !== 8 > undefined 9 > ; -1->Emitted(6, 9) Source(16, 9) + SourceIndex(0) -2 >Emitted(6, 15) Source(16, 15) + SourceIndex(0) -3 >Emitted(6, 16) Source(16, 16) + SourceIndex(0) -4 >Emitted(6, 18) Source(16, 18) + SourceIndex(0) -5 >Emitted(6, 19) Source(16, 19) + SourceIndex(0) -6 >Emitted(6, 43) Source(16, 43) + SourceIndex(0) -7 >Emitted(6, 48) Source(16, 48) + SourceIndex(0) -8 >Emitted(6, 57) Source(16, 57) + SourceIndex(0) -9 >Emitted(6, 58) Source(16, 58) + SourceIndex(0) +1->Emitted(6, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(6, 15) Source(15, 15) + SourceIndex(0) +3 >Emitted(6, 16) Source(15, 16) + SourceIndex(0) +4 >Emitted(6, 18) Source(15, 18) + SourceIndex(0) +5 >Emitted(6, 19) Source(15, 19) + SourceIndex(0) +6 >Emitted(6, 43) Source(15, 43) + SourceIndex(0) +7 >Emitted(6, 48) Source(15, 48) + SourceIndex(0) +8 >Emitted(6, 57) Source(15, 57) + SourceIndex(0) +9 >Emitted(6, 58) Source(15, 58) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -110,8 +109,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(7, 5) Source(17, 5) + SourceIndex(0) -2 >Emitted(7, 6) Source(17, 6) + SourceIndex(0) +1 >Emitted(7, 5) Source(16, 5) + SourceIndex(0) +2 >Emitted(7, 6) Source(16, 6) + SourceIndex(0) --- >>> Element.isElement = isElement; 1->^^^^ @@ -125,10 +124,10 @@ sourceFile:Element.ts > return el.markAsChildOfRootElement !== undefined; > } 4 > -1->Emitted(8, 5) Source(15, 21) + SourceIndex(0) -2 >Emitted(8, 22) Source(15, 30) + SourceIndex(0) -3 >Emitted(8, 34) Source(17, 6) + SourceIndex(0) -4 >Emitted(8, 35) Source(17, 6) + SourceIndex(0) +1->Emitted(8, 5) Source(14, 21) + SourceIndex(0) +2 >Emitted(8, 22) Source(14, 30) + SourceIndex(0) +3 >Emitted(8, 34) Source(16, 6) + SourceIndex(0) +4 >Emitted(8, 35) Source(16, 6) + SourceIndex(0) --- >>> function createElement(args) { 1->^^^^ @@ -139,9 +138,9 @@ sourceFile:Element.ts > 2 > export function createElement( 3 > args: any[] -1->Emitted(9, 5) Source(19, 5) + SourceIndex(0) -2 >Emitted(9, 28) Source(19, 35) + SourceIndex(0) -3 >Emitted(9, 32) Source(19, 46) + SourceIndex(0) +1->Emitted(9, 5) Source(18, 5) + SourceIndex(0) +2 >Emitted(9, 28) Source(18, 35) + SourceIndex(0) +3 >Emitted(9, 32) Source(18, 46) + SourceIndex(0) --- >>> return {}; 1 >^^^^^^^^ @@ -157,11 +156,11 @@ sourceFile:Element.ts 4 > { > } 5 > -1 >Emitted(10, 9) Source(21, 9) + SourceIndex(0) -2 >Emitted(10, 15) Source(21, 15) + SourceIndex(0) -3 >Emitted(10, 16) Source(21, 16) + SourceIndex(0) -4 >Emitted(10, 18) Source(22, 10) + SourceIndex(0) -5 >Emitted(10, 19) Source(22, 10) + SourceIndex(0) +1 >Emitted(10, 9) Source(20, 9) + SourceIndex(0) +2 >Emitted(10, 15) Source(20, 15) + SourceIndex(0) +3 >Emitted(10, 16) Source(20, 16) + SourceIndex(0) +4 >Emitted(10, 18) Source(21, 10) + SourceIndex(0) +5 >Emitted(10, 19) Source(21, 10) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -170,8 +169,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(11, 5) Source(23, 5) + SourceIndex(0) -2 >Emitted(11, 6) Source(23, 6) + SourceIndex(0) +1 >Emitted(11, 5) Source(22, 5) + SourceIndex(0) +2 >Emitted(11, 6) Source(22, 6) + SourceIndex(0) --- >>> Element.createElement = createElement; 1->^^^^ @@ -187,10 +186,10 @@ sourceFile:Element.ts > } > } 4 > -1->Emitted(12, 5) Source(19, 21) + SourceIndex(0) -2 >Emitted(12, 26) Source(19, 34) + SourceIndex(0) -3 >Emitted(12, 42) Source(23, 6) + SourceIndex(0) -4 >Emitted(12, 43) Source(23, 6) + SourceIndex(0) +1->Emitted(12, 5) Source(18, 21) + SourceIndex(0) +2 >Emitted(12, 26) Source(18, 34) + SourceIndex(0) +3 >Emitted(12, 42) Source(22, 6) + SourceIndex(0) +4 >Emitted(12, 43) Source(22, 6) + SourceIndex(0) --- >>>})(Element = exports.Element || (exports.Element = {})); 1-> @@ -222,15 +221,15 @@ sourceFile:Element.ts > } > } > } -1->Emitted(13, 1) Source(24, 1) + SourceIndex(0) -2 >Emitted(13, 2) Source(24, 2) + SourceIndex(0) -3 >Emitted(13, 4) Source(14, 18) + SourceIndex(0) -4 >Emitted(13, 11) Source(14, 25) + SourceIndex(0) -5 >Emitted(13, 14) Source(14, 18) + SourceIndex(0) -6 >Emitted(13, 29) Source(14, 25) + SourceIndex(0) -7 >Emitted(13, 34) Source(14, 18) + SourceIndex(0) -8 >Emitted(13, 49) Source(14, 25) + SourceIndex(0) -9 >Emitted(13, 57) Source(24, 2) + SourceIndex(0) +1->Emitted(13, 1) Source(23, 1) + SourceIndex(0) +2 >Emitted(13, 2) Source(23, 2) + SourceIndex(0) +3 >Emitted(13, 4) Source(13, 18) + SourceIndex(0) +4 >Emitted(13, 11) Source(13, 25) + SourceIndex(0) +5 >Emitted(13, 14) Source(13, 18) + SourceIndex(0) +6 >Emitted(13, 29) Source(13, 25) + SourceIndex(0) +7 >Emitted(13, 34) Source(13, 18) + SourceIndex(0) +8 >Emitted(13, 49) Source(13, 25) + SourceIndex(0) +9 >Emitted(13, 57) Source(23, 2) + SourceIndex(0) --- >>>exports.createElement = Element.createElement; 1 > @@ -251,14 +250,14 @@ sourceFile:Element.ts 6 > . 7 > createElement 8 > ; -1 >Emitted(14, 1) Source(26, 12) + SourceIndex(0) -2 >Emitted(14, 9) Source(26, 12) + SourceIndex(0) -3 >Emitted(14, 22) Source(26, 25) + SourceIndex(0) -4 >Emitted(14, 25) Source(26, 28) + SourceIndex(0) -5 >Emitted(14, 32) Source(26, 35) + SourceIndex(0) -6 >Emitted(14, 33) Source(26, 36) + SourceIndex(0) -7 >Emitted(14, 46) Source(26, 49) + SourceIndex(0) -8 >Emitted(14, 47) Source(26, 50) + SourceIndex(0) +1 >Emitted(14, 1) Source(25, 12) + SourceIndex(0) +2 >Emitted(14, 9) Source(25, 12) + SourceIndex(0) +3 >Emitted(14, 22) Source(25, 25) + SourceIndex(0) +4 >Emitted(14, 25) Source(25, 28) + SourceIndex(0) +5 >Emitted(14, 32) Source(25, 35) + SourceIndex(0) +6 >Emitted(14, 33) Source(25, 36) + SourceIndex(0) +7 >Emitted(14, 46) Source(25, 49) + SourceIndex(0) +8 >Emitted(14, 47) Source(25, 50) + SourceIndex(0) --- >>>function toCamelCase(text) { 1 > @@ -270,9 +269,9 @@ sourceFile:Element.ts > 2 >function toCamelCase( 3 > text: string -1 >Emitted(15, 1) Source(28, 1) + SourceIndex(0) -2 >Emitted(15, 22) Source(28, 22) + SourceIndex(0) -3 >Emitted(15, 26) Source(28, 34) + SourceIndex(0) +1 >Emitted(15, 1) Source(27, 1) + SourceIndex(0) +2 >Emitted(15, 22) Source(27, 22) + SourceIndex(0) +3 >Emitted(15, 26) Source(27, 34) + SourceIndex(0) --- >>> return text[0].toLowerCase() + text.substring(1); 1->^^^^ @@ -312,24 +311,24 @@ sourceFile:Element.ts 16> 1 17> ) 18> ; -1->Emitted(16, 5) Source(29, 5) + SourceIndex(0) -2 >Emitted(16, 11) Source(29, 11) + SourceIndex(0) -3 >Emitted(16, 12) Source(29, 12) + SourceIndex(0) -4 >Emitted(16, 16) Source(29, 16) + SourceIndex(0) -5 >Emitted(16, 17) Source(29, 17) + SourceIndex(0) -6 >Emitted(16, 18) Source(29, 18) + SourceIndex(0) -7 >Emitted(16, 19) Source(29, 19) + SourceIndex(0) -8 >Emitted(16, 20) Source(29, 20) + SourceIndex(0) -9 >Emitted(16, 31) Source(29, 31) + SourceIndex(0) -10>Emitted(16, 33) Source(29, 33) + SourceIndex(0) -11>Emitted(16, 36) Source(29, 36) + SourceIndex(0) -12>Emitted(16, 40) Source(29, 40) + SourceIndex(0) -13>Emitted(16, 41) Source(29, 41) + SourceIndex(0) -14>Emitted(16, 50) Source(29, 50) + SourceIndex(0) -15>Emitted(16, 51) Source(29, 51) + SourceIndex(0) -16>Emitted(16, 52) Source(29, 52) + SourceIndex(0) -17>Emitted(16, 53) Source(29, 53) + SourceIndex(0) -18>Emitted(16, 54) Source(29, 54) + SourceIndex(0) +1->Emitted(16, 5) Source(28, 5) + SourceIndex(0) +2 >Emitted(16, 11) Source(28, 11) + SourceIndex(0) +3 >Emitted(16, 12) Source(28, 12) + SourceIndex(0) +4 >Emitted(16, 16) Source(28, 16) + SourceIndex(0) +5 >Emitted(16, 17) Source(28, 17) + SourceIndex(0) +6 >Emitted(16, 18) Source(28, 18) + SourceIndex(0) +7 >Emitted(16, 19) Source(28, 19) + SourceIndex(0) +8 >Emitted(16, 20) Source(28, 20) + SourceIndex(0) +9 >Emitted(16, 31) Source(28, 31) + SourceIndex(0) +10>Emitted(16, 33) Source(28, 33) + SourceIndex(0) +11>Emitted(16, 36) Source(28, 36) + SourceIndex(0) +12>Emitted(16, 40) Source(28, 40) + SourceIndex(0) +13>Emitted(16, 41) Source(28, 41) + SourceIndex(0) +14>Emitted(16, 50) Source(28, 50) + SourceIndex(0) +15>Emitted(16, 51) Source(28, 51) + SourceIndex(0) +16>Emitted(16, 52) Source(28, 52) + SourceIndex(0) +17>Emitted(16, 53) Source(28, 53) + SourceIndex(0) +18>Emitted(16, 54) Source(28, 54) + SourceIndex(0) --- >>>} 1 > @@ -338,8 +337,8 @@ sourceFile:Element.ts 1 > > 2 >} -1 >Emitted(17, 1) Source(30, 1) + SourceIndex(0) -2 >Emitted(17, 2) Source(30, 2) + SourceIndex(0) +1 >Emitted(17, 1) Source(29, 1) + SourceIndex(0) +2 >Emitted(17, 2) Source(29, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=Element.js.map=================================================================== JsFile: test.js diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.symbols b/tests/baselines/reference/jsxFactoryQualifiedName.symbols index f2579903d3e..f20470ebb6b 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.symbols +++ b/tests/baselines/reference/jsxFactoryQualifiedName.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) interface Element { ->Element : Symbol(Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(Element, Decl(Element.ts, 0, 23)) name: string; ->name : Symbol(Element.name, Decl(Element.ts, 2, 23)) +>name : Symbol(Element.name, Decl(Element.ts, 1, 23)) isIntrinsic: boolean; ->isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 3, 21)) +>isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 2, 21)) isCustomElement: boolean; ->isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 4, 29)) +>isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 3, 29)) toString(renderId?: number): string; ->toString : Symbol(Element.toString, Decl(Element.ts, 5, 33)) ->renderId : Symbol(renderId, Decl(Element.ts, 6, 17)) +>toString : Symbol(Element.toString, Decl(Element.ts, 4, 33)) +>renderId : Symbol(renderId, Decl(Element.ts, 5, 17)) bindDOM(renderId?: number): number; ->bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 6, 44)) ->renderId : Symbol(renderId, Decl(Element.ts, 7, 16)) +>bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 5, 44)) +>renderId : Symbol(renderId, Decl(Element.ts, 6, 16)) resetComponent(): void; ->resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 7, 43)) +>resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 6, 43)) instantiateComponents(renderId?: number): number; ->instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 8, 31)) ->renderId : Symbol(renderId, Decl(Element.ts, 9, 30)) +>instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 7, 31)) +>renderId : Symbol(renderId, Decl(Element.ts, 8, 30)) props: any; ->props : Symbol(Element.props, Decl(Element.ts, 9, 57)) +>props : Symbol(Element.props, Decl(Element.ts, 8, 57)) } } export namespace Element { ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) export function isElement(el: any): el is JSX.Element { ->isElement : Symbol(isElement, Decl(Element.ts, 13, 26)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>isElement : Symbol(isElement, Decl(Element.ts, 12, 26)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) ->Element : Symbol(JSX.Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(JSX.Element, Decl(Element.ts, 0, 23)) return el.markAsChildOfRootElement !== undefined; ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >undefined : Symbol(undefined) } export function createElement(args: any[]) { ->createElement : Symbol(createElement, Decl(Element.ts, 16, 5)) ->args : Symbol(args, Decl(Element.ts, 18, 34)) +>createElement : Symbol(createElement, Decl(Element.ts, 15, 5)) +>args : Symbol(args, Decl(Element.ts, 17, 34)) return { } @@ -59,21 +58,21 @@ export namespace Element { } export let createElement = Element.createElement; ->createElement : Symbol(createElement, Decl(Element.ts, 25, 10)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(createElement, Decl(Element.ts, 24, 10)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) function toCamelCase(text: string): string { ->toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 25, 49)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 24, 49)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) return text[0].toLowerCase() + text.substring(1); >text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) >text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.types b/tests/baselines/reference/jsxFactoryQualifiedName.types index 724aed319ec..044b65222a9 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.types +++ b/tests/baselines/reference/jsxFactoryQualifiedName.types @@ -1,5 +1,4 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt index 97a05d840f0..f7f066175a0 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.tsx(10,17): error TS2304: Cannot find name 'MyElement'. +tests/cases/compiler/test.tsx(9,17): error TS2304: Cannot find name 'MyElement'. ==== tests/cases/compiler/test.tsx (1 errors) ==== - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js index 510efc97f4a..c8a90a69cc2 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map index 1af641eb351..5927e451e8c 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map @@ -1,2 +1,2 @@ //// [test.js.map] -{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAOA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,oCAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file +{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAMA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,oCAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt index 2f5270f3705..ee89acac087 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt @@ -13,15 +13,14 @@ sourceFile:test.tsx >>>class AppComponent { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface IntrinsicElements { > [s: string]: any; > } >} > > -1 >Emitted(3, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(3, 1) Source(7, 1) + SourceIndex(0) --- >>> render(createElement) { 1->^^^^ @@ -34,10 +33,10 @@ sourceFile:test.tsx 2 > render 3 > ( 4 > createElement -1->Emitted(4, 5) Source(9, 5) + SourceIndex(0) -2 >Emitted(4, 11) Source(9, 11) + SourceIndex(0) -3 >Emitted(4, 12) Source(9, 12) + SourceIndex(0) -4 >Emitted(4, 25) Source(9, 25) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 5) + SourceIndex(0) +2 >Emitted(4, 11) Source(8, 11) + SourceIndex(0) +3 >Emitted(4, 12) Source(8, 12) + SourceIndex(0) +4 >Emitted(4, 25) Source(8, 25) + SourceIndex(0) --- >>> return MyElement.createElement("div", null); 1->^^^^^^^^ @@ -51,11 +50,11 @@ sourceFile:test.tsx 3 > 4 >
5 > ; -1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) -4 >Emitted(5, 52) Source(10, 23) + SourceIndex(0) -5 >Emitted(5, 53) Source(10, 24) + SourceIndex(0) +1->Emitted(5, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(9, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(9, 16) + SourceIndex(0) +4 >Emitted(5, 52) Source(9, 23) + SourceIndex(0) +5 >Emitted(5, 53) Source(9, 24) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -63,15 +62,15 @@ sourceFile:test.tsx 1 > > 2 > } -1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(10, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(11, 2) + SourceIndex(0) --- >>>exports.AppComponent = AppComponent; 1-> @@ -82,7 +81,7 @@ sourceFile:test.tsx > return
; > } >} -1->Emitted(8, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(8, 37) Source(12, 2) + SourceIndex(0) +1->Emitted(8, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(8, 37) Source(11, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=test.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js index 267f3eaee50..b549fb58a0a 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js +++ b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js @@ -1,5 +1,4 @@ //// [index.tsx] - import "./jsx"; var skate: any; diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols index 35879c81ca6..e06b8e345e8 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols +++ b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/index.tsx === - import "./jsx"; var skate: any; ->skate : Symbol(skate, Decl(index.tsx, 3, 3)) +>skate : Symbol(skate, Decl(index.tsx, 2, 3)) const React = { createElement: skate.h }; ->React : Symbol(React, Decl(index.tsx, 4, 5)) ->createElement : Symbol(createElement, Decl(index.tsx, 4, 15)) ->skate : Symbol(skate, Decl(index.tsx, 3, 3)) +>React : Symbol(React, Decl(index.tsx, 3, 5)) +>createElement : Symbol(createElement, Decl(index.tsx, 3, 15)) +>skate : Symbol(skate, Decl(index.tsx, 2, 3)) class Component { ->Component : Symbol(Component, Decl(index.tsx, 4, 41)) +>Component : Symbol(Component, Decl(index.tsx, 3, 41)) renderCallback() { ->renderCallback : Symbol(Component.renderCallback, Decl(index.tsx, 6, 17)) +>renderCallback : Symbol(Component.renderCallback, Decl(index.tsx, 5, 17)) return
test
; >div : Symbol(unknown) diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types index 21fd4bae84b..6f6ae3f2d58 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types +++ b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/index.tsx === - import "./jsx"; var skate: any; diff --git a/tests/baselines/reference/jsxImportInAttribute.js b/tests/baselines/reference/jsxImportInAttribute.js index 4b42ebe812d..b249d88a6c2 100644 --- a/tests/baselines/reference/jsxImportInAttribute.js +++ b/tests/baselines/reference/jsxImportInAttribute.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxImportInAttribute.tsx] //// //// [component.d.ts] - declare module "Test" { export default class Text { } } diff --git a/tests/baselines/reference/jsxImportInAttribute.symbols b/tests/baselines/reference/jsxImportInAttribute.symbols index daf4dd110a3..44c746c7de6 100644 --- a/tests/baselines/reference/jsxImportInAttribute.symbols +++ b/tests/baselines/reference/jsxImportInAttribute.symbols @@ -13,9 +13,8 @@ let x = Test; // emit test_1.default >Test : Symbol(Test, Decl(consumer.tsx, 1, 6)) === tests/cases/compiler/component.d.ts === - declare module "Test" { export default class Text { } ->Text : Symbol(Text, Decl(component.d.ts, 1, 23)) +>Text : Symbol(Text, Decl(component.d.ts, 0, 23)) } diff --git a/tests/baselines/reference/jsxImportInAttribute.types b/tests/baselines/reference/jsxImportInAttribute.types index b4317f508c2..0c24f0156ba 100644 --- a/tests/baselines/reference/jsxImportInAttribute.types +++ b/tests/baselines/reference/jsxImportInAttribute.types @@ -14,7 +14,6 @@ let x = Test; // emit test_1.default >Test : typeof Test === tests/cases/compiler/component.d.ts === - declare module "Test" { export default class Text { } >Text : Text diff --git a/tests/baselines/reference/jsxParsingError1.errors.txt b/tests/baselines/reference/jsxParsingError1.errors.txt index e769947dfa6..dec1228fd72 100644 --- a/tests/baselines/reference/jsxParsingError1.errors.txt +++ b/tests/baselines/reference/jsxParsingError1.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/jsx/file.tsx(12,36): error TS1005: '}' expected. -tests/cases/conformance/jsx/file.tsx(12,44): error TS1003: Identifier expected. -tests/cases/conformance/jsx/file.tsx(12,46): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/file.tsx(11,36): error TS1005: '}' expected. +tests/cases/conformance/jsx/file.tsx(11,44): error TS1003: Identifier expected. +tests/cases/conformance/jsx/file.tsx(11,46): error TS1161: Unterminated regular expression literal. ==== tests/cases/conformance/jsx/file.tsx (3 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/jsxParsingError1.js b/tests/baselines/reference/jsxParsingError1.js index 14b60afdde8..bf2d48b0491 100644 --- a/tests/baselines/reference/jsxParsingError1.js +++ b/tests/baselines/reference/jsxParsingError1.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/jsxParsingError2.errors.txt b/tests/baselines/reference/jsxParsingError2.errors.txt index 9d9922228f9..cdf34baf4e1 100644 --- a/tests/baselines/reference/jsxParsingError2.errors.txt +++ b/tests/baselines/reference/jsxParsingError2.errors.txt @@ -13,7 +13,6 @@ tests/cases/conformance/jsx/Error5.tsx(3,1): error TS1005: 'elemA : Symbol(elemA, Decl(a.js, 1, 3)) +>elemA : Symbol(elemA, Decl(a.js, 0, 3)) === tests/cases/compiler/b.jsx === var elemB = {"test"}; diff --git a/tests/baselines/reference/jsxPreserveWithJsInput.types b/tests/baselines/reference/jsxPreserveWithJsInput.types index 4ae5c6aeed4..a38d884b4fa 100644 --- a/tests/baselines/reference/jsxPreserveWithJsInput.types +++ b/tests/baselines/reference/jsxPreserveWithJsInput.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - var elemA = 42; >elemA : number >42 : 42 diff --git a/tests/baselines/reference/jsxReactTestSuite.js b/tests/baselines/reference/jsxReactTestSuite.js index 392f1736407..3d11e01c51a 100644 --- a/tests/baselines/reference/jsxReactTestSuite.js +++ b/tests/baselines/reference/jsxReactTestSuite.js @@ -1,5 +1,4 @@ //// [jsxReactTestSuite.tsx] - declare var React: any; declare var Component:any; declare var Composite:any; diff --git a/tests/baselines/reference/jsxReactTestSuite.symbols b/tests/baselines/reference/jsxReactTestSuite.symbols index 36c0eef93a8..6ee9f629d43 100644 --- a/tests/baselines/reference/jsxReactTestSuite.symbols +++ b/tests/baselines/reference/jsxReactTestSuite.symbols @@ -1,40 +1,39 @@ === tests/cases/conformance/jsx/jsxReactTestSuite.tsx === - declare var React: any; ->React : Symbol(React, Decl(jsxReactTestSuite.tsx, 1, 11)) +>React : Symbol(React, Decl(jsxReactTestSuite.tsx, 0, 11)) declare var Component:any; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) declare var Composite:any; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) declare var Composite2:any; ->Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 4, 11)) +>Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 3, 11)) declare var Child:any; ->Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 5, 11)) +>Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 4, 11)) declare var Namespace:any; ->Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 5, 11)) declare var foo: any; ->foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 7, 11)) +>foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 6, 11)) declare var bar: any; ->bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 8, 11)) +>bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 7, 11)) declare var y:any; ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 8, 11)) declare var x:any; ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) declare var z:any; ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) declare var hasOwnProperty:any; ->hasOwnProperty : Symbol(hasOwnProperty, Decl(jsxReactTestSuite.tsx, 12, 11)) +>hasOwnProperty : Symbol(hasOwnProperty, Decl(jsxReactTestSuite.tsx, 11, 11))
text
; >div : Symbol(unknown) @@ -56,11 +55,11 @@ declare var hasOwnProperty:any; >div : Symbol(unknown) {foo}
{bar} ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 7, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 6, 11)) >br : Symbol(unknown) ->bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 8, 11)) ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 7, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11))
>br : Symbol(unknown) @@ -70,48 +69,48 @@ declare var hasOwnProperty:any; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) {this.props.children} ; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) ->Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 4, 11)) +>Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 3, 11)) ; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) var x = ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3))
div : Symbol(unknown) attr1={ ->attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 36, 6)) +>attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 35, 6)) "foo" + "bar" } attr2={ ->attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 39, 5)) +>attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 38, 5)) "foo" + "bar" + "baz" + "bug" } attr3={ ->attr3 : Symbol(attr3, Decl(jsxReactTestSuite.tsx, 44, 5)) +>attr3 : Symbol(attr3, Decl(jsxReactTestSuite.tsx, 43, 5)) "foo" + "bar" + "baz" + "bug" // Extra line here. } attr4="baz"> ->attr4 : Symbol(attr4, Decl(jsxReactTestSuite.tsx, 49, 5)) +>attr4 : Symbol(attr4, Decl(jsxReactTestSuite.tsx, 48, 5))
; >div : Symbol(unknown) @@ -147,13 +146,13 @@ var x = /* a multi-line comment */ attr1="foo"> ->attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 68, 6)) +>attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 67, 6)) span : Symbol(unknown) attr2="bar" ->attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 72, 9)) +>attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 71, 9)) />
@@ -174,78 +173,78 @@ var x = >hasOwnProperty : Symbol(unknown) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->constructor : Symbol(constructor, Decl(jsxReactTestSuite.tsx, 84, 10)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>constructor : Symbol(constructor, Decl(jsxReactTestSuite.tsx, 83, 10)) ; ->Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 5, 11)) ; ->Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 5, 11)) Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 90, 20)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 89, 20)) ={2 } z />; ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 91, 5)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 90, 5)) Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) {...this.props} sound="moo" />; ->sound : Symbol(sound, Decl(jsxReactTestSuite.tsx, 94, 19)) +>sound : Symbol(sound, Decl(jsxReactTestSuite.tsx, 93, 19)) ; >font-face : Symbol(unknown) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 98, 10)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 97, 10)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 8, 11)) ; >x-component : Symbol(unknown) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 104, 19)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 103, 19)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 106, 20)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 106, 26)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 105, 20)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 105, 26)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 108, 10)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 107, 10)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 8, 11)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 111, 10)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 111, 16)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 5, 11)) ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 110, 10)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 110, 16)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 4, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) Text; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 113, 10)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 113, 27)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 113, 39)) ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 112, 10)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 112, 27)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 112, 39)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) diff --git a/tests/baselines/reference/jsxReactTestSuite.types b/tests/baselines/reference/jsxReactTestSuite.types index bd120ba9df2..28ed2e5960a 100644 --- a/tests/baselines/reference/jsxReactTestSuite.types +++ b/tests/baselines/reference/jsxReactTestSuite.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/jsxReactTestSuite.tsx === - declare var React: any; >React : any diff --git a/tests/baselines/reference/jsxViaImport.2.js b/tests/baselines/reference/jsxViaImport.2.js index 187ba545fb3..813df2de938 100644 --- a/tests/baselines/reference/jsxViaImport.2.js +++ b/tests/baselines/reference/jsxViaImport.2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxViaImport.2.tsx] //// //// [component.d.ts] - declare module JSX { interface ElementAttributesProperty { props; } } diff --git a/tests/baselines/reference/jsxViaImport.2.symbols b/tests/baselines/reference/jsxViaImport.2.symbols index 5fb24088d2e..40c38b9e4d5 100644 --- a/tests/baselines/reference/jsxViaImport.2.symbols +++ b/tests/baselines/reference/jsxViaImport.2.symbols @@ -5,9 +5,9 @@ import BaseComponent from 'BaseComponent'; class TestComponent extends React.Component { >TestComponent : Symbol(TestComponent, Decl(consumer.tsx, 1, 42)) ->React.Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) ->React : Symbol(React, Decl(component.d.ts, 3, 1)) ->Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) +>React.Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) +>React : Symbol(React, Decl(component.d.ts, 2, 1)) +>Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) render() { >render : Symbol(TestComponent.render, Decl(consumer.tsx, 2, 54)) @@ -18,27 +18,26 @@ class TestComponent extends React.Component { } === tests/cases/compiler/component.d.ts === - declare module JSX { >JSX : Symbol(JSX, Decl(component.d.ts, 0, 0)) interface ElementAttributesProperty { props; } ->ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(component.d.ts, 1, 20)) ->props : Symbol(ElementAttributesProperty.props, Decl(component.d.ts, 2, 39)) +>ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(component.d.ts, 0, 20)) +>props : Symbol(ElementAttributesProperty.props, Decl(component.d.ts, 1, 39)) } declare module React { ->React : Symbol(React, Decl(component.d.ts, 3, 1)) +>React : Symbol(React, Decl(component.d.ts, 2, 1)) class Component { } ->Component : Symbol(Component, Decl(component.d.ts, 4, 22)) ->T : Symbol(T, Decl(component.d.ts, 5, 18)) ->U : Symbol(U, Decl(component.d.ts, 5, 20)) +>Component : Symbol(Component, Decl(component.d.ts, 3, 22)) +>T : Symbol(T, Decl(component.d.ts, 4, 18)) +>U : Symbol(U, Decl(component.d.ts, 4, 20)) } declare module "BaseComponent" { export default class extends React.Component { ->React.Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) ->React : Symbol(React, Decl(component.d.ts, 3, 1)) ->Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) +>React.Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) +>React : Symbol(React, Decl(component.d.ts, 2, 1)) +>Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) } } diff --git a/tests/baselines/reference/jsxViaImport.2.types b/tests/baselines/reference/jsxViaImport.2.types index c1e418c6b32..396c4d381a0 100644 --- a/tests/baselines/reference/jsxViaImport.2.types +++ b/tests/baselines/reference/jsxViaImport.2.types @@ -19,7 +19,6 @@ class TestComponent extends React.Component { } === tests/cases/compiler/component.d.ts === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/jsxViaImport.errors.txt b/tests/baselines/reference/jsxViaImport.errors.txt index 8fa22809a44..fef730db459 100644 --- a/tests/baselines/reference/jsxViaImport.errors.txt +++ b/tests/baselines/reference/jsxViaImport.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/consumer.tsx(5,17): error TS2604: JSX element type 'BaseCom } ==== tests/cases/compiler/component.d.ts (0 errors) ==== - declare module JSX { interface ElementAttributesProperty { props; } } diff --git a/tests/baselines/reference/jsxViaImport.js b/tests/baselines/reference/jsxViaImport.js index 3b291a34774..cfbbb9eb456 100644 --- a/tests/baselines/reference/jsxViaImport.js +++ b/tests/baselines/reference/jsxViaImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxViaImport.tsx] //// //// [component.d.ts] - declare module JSX { interface ElementAttributesProperty { props; } } diff --git a/tests/baselines/reference/keepImportsInDts1.js b/tests/baselines/reference/keepImportsInDts1.js index 3f945a5ebc3..e58702de229 100644 --- a/tests/baselines/reference/keepImportsInDts1.js +++ b/tests/baselines/reference/keepImportsInDts1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts1.ts] //// //// [test.d.ts] - export {}; //// [main.ts] import "test" diff --git a/tests/baselines/reference/keepImportsInDts1.symbols b/tests/baselines/reference/keepImportsInDts1.symbols index 92bd84c2088..0d0e7b9ccfd 100644 --- a/tests/baselines/reference/keepImportsInDts1.symbols +++ b/tests/baselines/reference/keepImportsInDts1.symbols @@ -1,6 +1,5 @@ === c:/test.d.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts1.types b/tests/baselines/reference/keepImportsInDts1.types index 92bd84c2088..0d0e7b9ccfd 100644 --- a/tests/baselines/reference/keepImportsInDts1.types +++ b/tests/baselines/reference/keepImportsInDts1.types @@ -1,6 +1,5 @@ === c:/test.d.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts2.js b/tests/baselines/reference/keepImportsInDts2.js index acd75a00c87..6e659f489da 100644 --- a/tests/baselines/reference/keepImportsInDts2.js +++ b/tests/baselines/reference/keepImportsInDts2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts2.ts] //// //// [test.ts] - export {}; //// [main.ts] import "./folder/test" diff --git a/tests/baselines/reference/keepImportsInDts2.symbols b/tests/baselines/reference/keepImportsInDts2.symbols index ce6f4c7c168..a18db585da9 100644 --- a/tests/baselines/reference/keepImportsInDts2.symbols +++ b/tests/baselines/reference/keepImportsInDts2.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts2.types b/tests/baselines/reference/keepImportsInDts2.types index ce6f4c7c168..a18db585da9 100644 --- a/tests/baselines/reference/keepImportsInDts2.types +++ b/tests/baselines/reference/keepImportsInDts2.types @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts3.js b/tests/baselines/reference/keepImportsInDts3.js index aec2e544e2f..6589c675eaa 100644 --- a/tests/baselines/reference/keepImportsInDts3.js +++ b/tests/baselines/reference/keepImportsInDts3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts3.ts] //// //// [test.ts] - export {}; //// [main.ts] import "test" diff --git a/tests/baselines/reference/keepImportsInDts3.symbols b/tests/baselines/reference/keepImportsInDts3.symbols index 29c4a4e44b4..552c6ff0be6 100644 --- a/tests/baselines/reference/keepImportsInDts3.symbols +++ b/tests/baselines/reference/keepImportsInDts3.symbols @@ -1,6 +1,5 @@ === c:/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts3.types b/tests/baselines/reference/keepImportsInDts3.types index 29c4a4e44b4..552c6ff0be6 100644 --- a/tests/baselines/reference/keepImportsInDts3.types +++ b/tests/baselines/reference/keepImportsInDts3.types @@ -1,6 +1,5 @@ === c:/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts4.js b/tests/baselines/reference/keepImportsInDts4.js index 3a959bcbbac..41c07e83668 100644 --- a/tests/baselines/reference/keepImportsInDts4.js +++ b/tests/baselines/reference/keepImportsInDts4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts4.ts] //// //// [test.ts] - export {}; //// [main.ts] import "./folder/test" diff --git a/tests/baselines/reference/keepImportsInDts4.symbols b/tests/baselines/reference/keepImportsInDts4.symbols index ce6f4c7c168..a18db585da9 100644 --- a/tests/baselines/reference/keepImportsInDts4.symbols +++ b/tests/baselines/reference/keepImportsInDts4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts4.types b/tests/baselines/reference/keepImportsInDts4.types index ce6f4c7c168..a18db585da9 100644 --- a/tests/baselines/reference/keepImportsInDts4.types +++ b/tests/baselines/reference/keepImportsInDts4.types @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keyofAndForIn.js b/tests/baselines/reference/keyofAndForIn.js index 0debf28b75e..4a880fe7d4d 100644 --- a/tests/baselines/reference/keyofAndForIn.js +++ b/tests/baselines/reference/keyofAndForIn.js @@ -1,5 +1,4 @@ //// [keyofAndForIn.ts] - // Repro from #12513 function f1(obj: { [P in K]: T }, k: K) { diff --git a/tests/baselines/reference/keyofAndForIn.symbols b/tests/baselines/reference/keyofAndForIn.symbols index 36b5d3e2d72..11a6d854798 100644 --- a/tests/baselines/reference/keyofAndForIn.symbols +++ b/tests/baselines/reference/keyofAndForIn.symbols @@ -1,125 +1,124 @@ === tests/cases/conformance/types/keyof/keyofAndForIn.ts === - // Repro from #12513 function f1(obj: { [P in K]: T }, k: K) { >f1 : Symbol(f1, Decl(keyofAndForIn.ts, 0, 0)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 3, 29)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 3, 41)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 3, 29)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 3, 54)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 2, 29)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 2, 41)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 2, 29)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 2, 54)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) const b = k in obj; ->b : Symbol(b, Decl(keyofAndForIn.ts, 4, 9)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 3, 54)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) +>b : Symbol(b, Decl(keyofAndForIn.ts, 3, 9)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 2, 54)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) let k1: K; ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 5, 7)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 4, 7)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) for (k1 in obj) { ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 5, 7)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 4, 7)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) let x1 = obj[k1]; ->x1 : Symbol(x1, Decl(keyofAndForIn.ts, 7, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 5, 7)) +>x1 : Symbol(x1, Decl(keyofAndForIn.ts, 6, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 4, 7)) } for (let k2 in obj) { ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 9, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 8, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) let x2 = obj[k2]; ->x2 : Symbol(x2, Decl(keyofAndForIn.ts, 10, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 9, 12)) +>x2 : Symbol(x2, Decl(keyofAndForIn.ts, 9, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 8, 12)) } } function f2(obj: { [P in keyof T]: T[P] }, k: keyof T) { ->f2 : Symbol(f2, Decl(keyofAndForIn.ts, 12, 1)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 14, 23)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 14, 23)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 14, 45)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) +>f2 : Symbol(f2, Decl(keyofAndForIn.ts, 11, 1)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 13, 23)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 13, 23)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 13, 45)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) const b = k in obj; ->b : Symbol(b, Decl(keyofAndForIn.ts, 15, 9)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 14, 45)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) +>b : Symbol(b, Decl(keyofAndForIn.ts, 14, 9)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 13, 45)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) let k1: keyof T; ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 16, 7)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 15, 7)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) for (k1 in obj) { ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 16, 7)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 15, 7)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) let x1 = obj[k1]; ->x1 : Symbol(x1, Decl(keyofAndForIn.ts, 18, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 16, 7)) +>x1 : Symbol(x1, Decl(keyofAndForIn.ts, 17, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 15, 7)) } for (let k2 in obj) { ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 20, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 19, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) let x2 = obj[k2]; ->x2 : Symbol(x2, Decl(keyofAndForIn.ts, 21, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 20, 12)) +>x2 : Symbol(x2, Decl(keyofAndForIn.ts, 20, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 19, 12)) } } function f3(obj: { [P in K]: T[P] }, k: K) { ->f3 : Symbol(f3, Decl(keyofAndForIn.ts, 23, 1)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 25, 12)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 25, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 25, 42)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 25, 12)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 25, 42)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 25, 58)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) +>f3 : Symbol(f3, Decl(keyofAndForIn.ts, 22, 1)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 24, 12)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 24, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 24, 42)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 24, 12)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 24, 42)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 24, 58)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) const b = k in obj; ->b : Symbol(b, Decl(keyofAndForIn.ts, 26, 9)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 25, 58)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) +>b : Symbol(b, Decl(keyofAndForIn.ts, 25, 9)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 24, 58)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) let k1: K; ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 27, 7)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 26, 7)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) for (k1 in obj) { ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 27, 7)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 26, 7)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) let x1 = obj[k1]; ->x1 : Symbol(x1, Decl(keyofAndForIn.ts, 29, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 27, 7)) +>x1 : Symbol(x1, Decl(keyofAndForIn.ts, 28, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 26, 7)) } for (let k2 in obj) { ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 31, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 30, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) let x2 = obj[k2]; ->x2 : Symbol(x2, Decl(keyofAndForIn.ts, 32, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 31, 12)) +>x2 : Symbol(x2, Decl(keyofAndForIn.ts, 31, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 30, 12)) } } diff --git a/tests/baselines/reference/keyofAndForIn.types b/tests/baselines/reference/keyofAndForIn.types index 5e992e5d261..d20f1a57070 100644 --- a/tests/baselines/reference/keyofAndForIn.types +++ b/tests/baselines/reference/keyofAndForIn.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/keyof/keyofAndForIn.ts === - // Repro from #12513 function f1(obj: { [P in K]: T }, k: K) { diff --git a/tests/baselines/reference/keyofAndIndexedAccess.js b/tests/baselines/reference/keyofAndIndexedAccess.js index 2b1b22d3595..cbd9549b163 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.js +++ b/tests/baselines/reference/keyofAndIndexedAccess.js @@ -1,5 +1,4 @@ //// [keyofAndIndexedAccess.ts] - class Shape { name: string; width: number; diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols index f6425b5ed0e..0d25af248fe 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.symbols +++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols @@ -1,1965 +1,1964 @@ === tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts === - class Shape { >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) name: string; ->name : Symbol(Shape.name, Decl(keyofAndIndexedAccess.ts, 1, 13)) +>name : Symbol(Shape.name, Decl(keyofAndIndexedAccess.ts, 0, 13)) width: number; ->width : Symbol(Shape.width, Decl(keyofAndIndexedAccess.ts, 2, 17)) +>width : Symbol(Shape.width, Decl(keyofAndIndexedAccess.ts, 1, 17)) height: number; ->height : Symbol(Shape.height, Decl(keyofAndIndexedAccess.ts, 3, 18)) +>height : Symbol(Shape.height, Decl(keyofAndIndexedAccess.ts, 2, 18)) visible: boolean; ->visible : Symbol(Shape.visible, Decl(keyofAndIndexedAccess.ts, 4, 19)) +>visible : Symbol(Shape.visible, Decl(keyofAndIndexedAccess.ts, 3, 19)) } class TaggedShape extends Shape { ->TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 6, 1)) +>TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 5, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) tag: string; ->tag : Symbol(TaggedShape.tag, Decl(keyofAndIndexedAccess.ts, 8, 33)) +>tag : Symbol(TaggedShape.tag, Decl(keyofAndIndexedAccess.ts, 7, 33)) } class Item { ->Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 10, 1)) +>Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 9, 1)) name: string; ->name : Symbol(Item.name, Decl(keyofAndIndexedAccess.ts, 12, 12)) +>name : Symbol(Item.name, Decl(keyofAndIndexedAccess.ts, 11, 12)) price: number; ->price : Symbol(Item.price, Decl(keyofAndIndexedAccess.ts, 13, 17)) +>price : Symbol(Item.price, Decl(keyofAndIndexedAccess.ts, 12, 17)) } class Options { ->Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 15, 1)) +>Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 14, 1)) visible: "yes" | "no"; ->visible : Symbol(Options.visible, Decl(keyofAndIndexedAccess.ts, 17, 15)) +>visible : Symbol(Options.visible, Decl(keyofAndIndexedAccess.ts, 16, 15)) } type Dictionary = { [x: string]: T }; ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 16)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 21, 24)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 16)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 20, 16)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 20, 24)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 20, 16)) type NumericallyIndexed = { [x: number]: T }; ->NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 21, 40)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 22, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 22, 32)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 22, 24)) +>NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 20, 40)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 21, 32)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 24)) const enum E { A, B, C } ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 24, 14)) ->B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 24, 17)) ->C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 24, 20)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 23, 14)) +>B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 23, 17)) +>C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 23, 20)) type K00 = keyof any; // string ->K00 : Symbol(K00, Decl(keyofAndIndexedAccess.ts, 24, 24)) +>K00 : Symbol(K00, Decl(keyofAndIndexedAccess.ts, 23, 24)) type K01 = keyof string; // "toString" | "charAt" | ... ->K01 : Symbol(K01, Decl(keyofAndIndexedAccess.ts, 26, 21)) +>K01 : Symbol(K01, Decl(keyofAndIndexedAccess.ts, 25, 21)) type K02 = keyof number; // "toString" | "toFixed" | "toExponential" | ... ->K02 : Symbol(K02, Decl(keyofAndIndexedAccess.ts, 27, 24)) +>K02 : Symbol(K02, Decl(keyofAndIndexedAccess.ts, 26, 24)) type K03 = keyof boolean; // "valueOf" ->K03 : Symbol(K03, Decl(keyofAndIndexedAccess.ts, 28, 24)) +>K03 : Symbol(K03, Decl(keyofAndIndexedAccess.ts, 27, 24)) type K04 = keyof void; // never ->K04 : Symbol(K04, Decl(keyofAndIndexedAccess.ts, 29, 25)) +>K04 : Symbol(K04, Decl(keyofAndIndexedAccess.ts, 28, 25)) type K05 = keyof undefined; // never ->K05 : Symbol(K05, Decl(keyofAndIndexedAccess.ts, 30, 22)) +>K05 : Symbol(K05, Decl(keyofAndIndexedAccess.ts, 29, 22)) type K06 = keyof null; // never ->K06 : Symbol(K06, Decl(keyofAndIndexedAccess.ts, 31, 27)) +>K06 : Symbol(K06, Decl(keyofAndIndexedAccess.ts, 30, 27)) type K07 = keyof never; // never ->K07 : Symbol(K07, Decl(keyofAndIndexedAccess.ts, 32, 22)) +>K07 : Symbol(K07, Decl(keyofAndIndexedAccess.ts, 31, 22)) type K10 = keyof Shape; // "name" | "width" | "height" | "visible" ->K10 : Symbol(K10, Decl(keyofAndIndexedAccess.ts, 33, 23)) +>K10 : Symbol(K10, Decl(keyofAndIndexedAccess.ts, 32, 23)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K11 = keyof Shape[]; // "length" | "toString" | ... ->K11 : Symbol(K11, Decl(keyofAndIndexedAccess.ts, 35, 23)) +>K11 : Symbol(K11, Decl(keyofAndIndexedAccess.ts, 34, 23)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K12 = keyof Dictionary; // string ->K12 : Symbol(K12, Decl(keyofAndIndexedAccess.ts, 36, 25)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>K12 : Symbol(K12, Decl(keyofAndIndexedAccess.ts, 35, 25)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K13 = keyof {}; // never ->K13 : Symbol(K13, Decl(keyofAndIndexedAccess.ts, 37, 35)) +>K13 : Symbol(K13, Decl(keyofAndIndexedAccess.ts, 36, 35)) type K14 = keyof Object; // "constructor" | "toString" | ... ->K14 : Symbol(K14, Decl(keyofAndIndexedAccess.ts, 38, 20)) +>K14 : Symbol(K14, Decl(keyofAndIndexedAccess.ts, 37, 20)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type K15 = keyof E; // "toString" | "toFixed" | "toExponential" | ... ->K15 : Symbol(K15, Decl(keyofAndIndexedAccess.ts, 39, 24)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) +>K15 : Symbol(K15, Decl(keyofAndIndexedAccess.ts, 38, 24)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) type K16 = keyof [string, number]; // "0" | "1" | "length" | "toString" | ... ->K16 : Symbol(K16, Decl(keyofAndIndexedAccess.ts, 40, 19)) +>K16 : Symbol(K16, Decl(keyofAndIndexedAccess.ts, 39, 19)) type K17 = keyof (Shape | Item); // "name" ->K17 : Symbol(K17, Decl(keyofAndIndexedAccess.ts, 41, 34)) +>K17 : Symbol(K17, Decl(keyofAndIndexedAccess.ts, 40, 34)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 10, 1)) +>Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 9, 1)) type K18 = keyof (Shape & Item); // "name" | "width" | "height" | "visible" | "price" ->K18 : Symbol(K18, Decl(keyofAndIndexedAccess.ts, 42, 32)) +>K18 : Symbol(K18, Decl(keyofAndIndexedAccess.ts, 41, 32)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 10, 1)) +>Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 9, 1)) type K19 = keyof NumericallyIndexed // never ->K19 : Symbol(K19, Decl(keyofAndIndexedAccess.ts, 43, 32)) ->NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 21, 40)) +>K19 : Symbol(K19, Decl(keyofAndIndexedAccess.ts, 42, 32)) +>NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 20, 40)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type KeyOf = keyof T; ->KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 44, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 46, 11)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 46, 11)) +>KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 43, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 45, 11)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 45, 11)) type K20 = KeyOf; // "name" | "width" | "height" | "visible" ->K20 : Symbol(K20, Decl(keyofAndIndexedAccess.ts, 46, 24)) ->KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 44, 42)) +>K20 : Symbol(K20, Decl(keyofAndIndexedAccess.ts, 45, 24)) +>KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 43, 42)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K21 = KeyOf>; // string ->K21 : Symbol(K21, Decl(keyofAndIndexedAccess.ts, 48, 24)) ->KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 44, 42)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>K21 : Symbol(K21, Decl(keyofAndIndexedAccess.ts, 47, 24)) +>KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 43, 42)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type NAME = "name"; ->NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 49, 36)) +>NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 48, 36)) type WIDTH_OR_HEIGHT = "width" | "height"; ->WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 51, 19)) +>WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 50, 19)) type Q10 = Shape["name"]; // string ->Q10 : Symbol(Q10, Decl(keyofAndIndexedAccess.ts, 52, 42)) +>Q10 : Symbol(Q10, Decl(keyofAndIndexedAccess.ts, 51, 42)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q11 = Shape["width" | "height"]; // number ->Q11 : Symbol(Q11, Decl(keyofAndIndexedAccess.ts, 54, 25)) +>Q11 : Symbol(Q11, Decl(keyofAndIndexedAccess.ts, 53, 25)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q12 = Shape["name" | "visible"]; // string | boolean ->Q12 : Symbol(Q12, Decl(keyofAndIndexedAccess.ts, 55, 37)) +>Q12 : Symbol(Q12, Decl(keyofAndIndexedAccess.ts, 54, 37)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q20 = Shape[NAME]; // string ->Q20 : Symbol(Q20, Decl(keyofAndIndexedAccess.ts, 56, 37)) +>Q20 : Symbol(Q20, Decl(keyofAndIndexedAccess.ts, 55, 37)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 49, 36)) +>NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 48, 36)) type Q21 = Shape[WIDTH_OR_HEIGHT]; // number ->Q21 : Symbol(Q21, Decl(keyofAndIndexedAccess.ts, 58, 23)) +>Q21 : Symbol(Q21, Decl(keyofAndIndexedAccess.ts, 57, 23)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 51, 19)) +>WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 50, 19)) type Q30 = [string, number][0]; // string ->Q30 : Symbol(Q30, Decl(keyofAndIndexedAccess.ts, 59, 34)) +>Q30 : Symbol(Q30, Decl(keyofAndIndexedAccess.ts, 58, 34)) type Q31 = [string, number][1]; // number ->Q31 : Symbol(Q31, Decl(keyofAndIndexedAccess.ts, 61, 31)) +>Q31 : Symbol(Q31, Decl(keyofAndIndexedAccess.ts, 60, 31)) type Q32 = [string, number][2]; // string | number ->Q32 : Symbol(Q32, Decl(keyofAndIndexedAccess.ts, 62, 31)) +>Q32 : Symbol(Q32, Decl(keyofAndIndexedAccess.ts, 61, 31)) type Q33 = [string, number][E.A]; // string ->Q33 : Symbol(Q33, Decl(keyofAndIndexedAccess.ts, 63, 31)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 24, 14)) +>Q33 : Symbol(Q33, Decl(keyofAndIndexedAccess.ts, 62, 31)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 23, 14)) type Q34 = [string, number][E.B]; // number ->Q34 : Symbol(Q34, Decl(keyofAndIndexedAccess.ts, 64, 33)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 24, 17)) +>Q34 : Symbol(Q34, Decl(keyofAndIndexedAccess.ts, 63, 33)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 23, 17)) type Q35 = [string, number][E.C]; // string | number ->Q35 : Symbol(Q35, Decl(keyofAndIndexedAccess.ts, 65, 33)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 24, 20)) +>Q35 : Symbol(Q35, Decl(keyofAndIndexedAccess.ts, 64, 33)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 23, 20)) type Q36 = [string, number]["0"]; // string ->Q36 : Symbol(Q36, Decl(keyofAndIndexedAccess.ts, 66, 33)) +>Q36 : Symbol(Q36, Decl(keyofAndIndexedAccess.ts, 65, 33)) type Q37 = [string, number]["1"]; // string ->Q37 : Symbol(Q37, Decl(keyofAndIndexedAccess.ts, 67, 33)) +>Q37 : Symbol(Q37, Decl(keyofAndIndexedAccess.ts, 66, 33)) type Q40 = (Shape | Options)["visible"]; // boolean | "yes" | "no" ->Q40 : Symbol(Q40, Decl(keyofAndIndexedAccess.ts, 68, 33)) +>Q40 : Symbol(Q40, Decl(keyofAndIndexedAccess.ts, 67, 33)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 15, 1)) +>Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 14, 1)) type Q41 = (Shape & Options)["visible"]; // true & "yes" | true & "no" | false & "yes" | false & "no" ->Q41 : Symbol(Q41, Decl(keyofAndIndexedAccess.ts, 70, 40)) +>Q41 : Symbol(Q41, Decl(keyofAndIndexedAccess.ts, 69, 40)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 15, 1)) +>Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 14, 1)) type Q50 = Dictionary["howdy"]; // Shape ->Q50 : Symbol(Q50, Decl(keyofAndIndexedAccess.ts, 71, 40)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>Q50 : Symbol(Q50, Decl(keyofAndIndexedAccess.ts, 70, 40)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q51 = Dictionary[123]; // Shape ->Q51 : Symbol(Q51, Decl(keyofAndIndexedAccess.ts, 73, 38)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>Q51 : Symbol(Q51, Decl(keyofAndIndexedAccess.ts, 72, 38)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q52 = Dictionary[E.B]; // Shape ->Q52 : Symbol(Q52, Decl(keyofAndIndexedAccess.ts, 74, 34)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>Q52 : Symbol(Q52, Decl(keyofAndIndexedAccess.ts, 73, 34)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 24, 17)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 23, 17)) declare let cond: boolean; ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) function getProperty(obj: T, key: K) { ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 79, 21)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 79, 23)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 79, 21)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 79, 43)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 79, 21)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 79, 50)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 79, 23)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 78, 21)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 78, 23)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 78, 21)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 78, 43)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 78, 21)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 78, 50)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 78, 23)) return obj[key]; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 79, 43)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 79, 50)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 78, 43)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 78, 50)) } function setProperty(obj: T, key: K, value: T[K]) { ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 83, 23)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 83, 43)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 83, 50)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 83, 23)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 83, 58)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 83, 23)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 82, 23)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 82, 43)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 82, 50)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 82, 23)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 82, 58)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 82, 23)) obj[key] = value; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 83, 43)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 83, 50)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 83, 58)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 82, 43)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 82, 50)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 82, 58)) } function f10(shape: Shape) { ->f10 : Symbol(f10, Decl(keyofAndIndexedAccess.ts, 85, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) +>f10 : Symbol(f10, Decl(keyofAndIndexedAccess.ts, 84, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let name = getProperty(shape, "name"); // string ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 88, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 87, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) let widthOrHeight = getProperty(shape, cond ? "width" : "height"); // number ->widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 89, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 88, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) let nameOrVisible = getProperty(shape, cond ? "name" : "visible"); // string | boolean ->nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 90, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 89, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) setProperty(shape, "name", "rectangle"); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) setProperty(shape, cond ? "width" : "height", 10); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) setProperty(shape, cond ? "name" : "visible", true); // Technically not safe ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) } function f11(a: Shape[]) { ->f11 : Symbol(f11, Decl(keyofAndIndexedAccess.ts, 94, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 96, 13)) +>f11 : Symbol(f11, Decl(keyofAndIndexedAccess.ts, 93, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 95, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let len = getProperty(a, "length"); // number ->len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 97, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 96, 13)) +>len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 96, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 95, 13)) setProperty(a, "length", len); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 96, 13)) ->len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 97, 7)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 95, 13)) +>len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 96, 7)) } function f12(t: [Shape, boolean]) { ->f12 : Symbol(f12, Decl(keyofAndIndexedAccess.ts, 99, 1)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>f12 : Symbol(f12, Decl(keyofAndIndexedAccess.ts, 98, 1)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let len = getProperty(t, "length"); ->len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 102, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 101, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) let s2 = getProperty(t, "0"); // Shape ->s2 : Symbol(s2, Decl(keyofAndIndexedAccess.ts, 103, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>s2 : Symbol(s2, Decl(keyofAndIndexedAccess.ts, 102, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) let b2 = getProperty(t, "1"); // boolean ->b2 : Symbol(b2, Decl(keyofAndIndexedAccess.ts, 104, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>b2 : Symbol(b2, Decl(keyofAndIndexedAccess.ts, 103, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) } function f13(foo: any, bar: any) { ->f13 : Symbol(f13, Decl(keyofAndIndexedAccess.ts, 105, 1)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) ->bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 107, 22)) +>f13 : Symbol(f13, Decl(keyofAndIndexedAccess.ts, 104, 1)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) +>bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 106, 22)) let x = getProperty(foo, "x"); // any ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 108, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 107, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) let y = getProperty(foo, "100"); // any ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 109, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 108, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) let z = getProperty(foo, bar); // any ->z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 110, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) ->bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 107, 22)) +>z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 109, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) +>bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 106, 22)) } class Component { ->Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) +>Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) props: PropType; ->props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) +>props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) getProperty(key: K) { ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 115, 16)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 115, 42)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 115, 16)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 114, 16)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 114, 42)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 114, 16)) return this.props[key]; ->this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) ->props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 115, 42)) +>this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) +>props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 114, 42)) } setProperty(key: K, value: PropType[K]) { ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 118, 16)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 118, 42)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 118, 16)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 118, 49)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 118, 16)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 117, 16)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 117, 42)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 117, 16)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 117, 49)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 117, 16)) this.props[key] = value; ->this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) ->props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 118, 42)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 118, 49)) +>this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) +>props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 117, 42)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 117, 49)) } } function f20(component: Component) { ->f20 : Symbol(f20, Decl(keyofAndIndexedAccess.ts, 121, 1)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) +>f20 : Symbol(f20, Decl(keyofAndIndexedAccess.ts, 120, 1)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let name = component.getProperty("name"); // string ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 124, 7)) ->component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 123, 7)) +>component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) let widthOrHeight = component.getProperty(cond ? "width" : "height"); // number ->widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 125, 7)) ->component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 124, 7)) +>component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) let nameOrVisible = component.getProperty(cond ? "name" : "visible"); // string | boolean ->nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 126, 7)) ->component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 125, 7)) +>component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) component.setProperty("name", "rectangle"); ->component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) +>component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) component.setProperty(cond ? "width" : "height", 10) ->component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) component.setProperty(cond ? "name" : "visible", true); // Technically not safe ->component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) } function pluck(array: T[], key: K) { ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 132, 15)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 132, 17)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 132, 15)) ->array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 132, 37)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 132, 15)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 132, 48)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 132, 17)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 131, 15)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 131, 17)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 131, 15)) +>array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 131, 37)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 131, 15)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 131, 48)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 131, 17)) return array.map(x => x[key]); >array.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 132, 37)) +>array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 131, 37)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 133, 21)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 133, 21)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 132, 48)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 132, 21)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 132, 21)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 131, 48)) } function f30(shapes: Shape[]) { ->f30 : Symbol(f30, Decl(keyofAndIndexedAccess.ts, 134, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) +>f30 : Symbol(f30, Decl(keyofAndIndexedAccess.ts, 133, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let names = pluck(shapes, "name"); // string[] ->names : Symbol(names, Decl(keyofAndIndexedAccess.ts, 137, 7)) ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) +>names : Symbol(names, Decl(keyofAndIndexedAccess.ts, 136, 7)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) let widths = pluck(shapes, "width"); // number[] ->widths : Symbol(widths, Decl(keyofAndIndexedAccess.ts, 138, 7)) ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) +>widths : Symbol(widths, Decl(keyofAndIndexedAccess.ts, 137, 7)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) let nameOrVisibles = pluck(shapes, cond ? "name" : "visible"); // (string | boolean)[] ->nameOrVisibles : Symbol(nameOrVisibles, Decl(keyofAndIndexedAccess.ts, 139, 7)) ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>nameOrVisibles : Symbol(nameOrVisibles, Decl(keyofAndIndexedAccess.ts, 138, 7)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) } function f31(key: K) { ->f31 : Symbol(f31, Decl(keyofAndIndexedAccess.ts, 140, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 142, 13)) +>f31 : Symbol(f31, Decl(keyofAndIndexedAccess.ts, 139, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 141, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 142, 36)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 142, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 141, 36)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 141, 13)) const shape: Shape = { name: "foo", width: 5, height: 10, visible: true }; ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 143, 9)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 142, 9)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 143, 26)) ->width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 143, 39)) ->height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 143, 49)) ->visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 143, 61)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 142, 26)) +>width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 142, 39)) +>height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 142, 49)) +>visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 142, 61)) return shape[key]; // Shape[K] ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 143, 9)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 142, 36)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 142, 9)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 141, 36)) } function f32(key: K) { ->f32 : Symbol(f32, Decl(keyofAndIndexedAccess.ts, 145, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 147, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 147, 43)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 147, 13)) +>f32 : Symbol(f32, Decl(keyofAndIndexedAccess.ts, 144, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 146, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 146, 43)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 146, 13)) const shape: Shape = { name: "foo", width: 5, height: 10, visible: true }; ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 148, 9)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 147, 9)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 148, 26)) ->width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 148, 39)) ->height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 148, 49)) ->visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 148, 61)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 147, 26)) +>width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 147, 39)) +>height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 147, 49)) +>visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 147, 61)) return shape[key]; // Shape[K] ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 148, 9)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 147, 43)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 147, 9)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 146, 43)) } function f33(shape: S, key: K) { ->f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 150, 1)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 152, 13)) +>f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 149, 1)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 151, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 152, 29)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 152, 13)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 152, 49)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 152, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 152, 58)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 152, 29)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 151, 29)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 151, 13)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 151, 49)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 151, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 151, 58)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 151, 29)) let name = getProperty(shape, "name"); ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 153, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 152, 49)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 152, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 151, 49)) let prop = getProperty(shape, key); ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 154, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 152, 49)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 152, 58)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 153, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 151, 49)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 151, 58)) return prop; ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 154, 7)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 153, 7)) } function f34(ts: TaggedShape) { ->f34 : Symbol(f34, Decl(keyofAndIndexedAccess.ts, 156, 1)) ->ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 158, 13)) ->TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 6, 1)) +>f34 : Symbol(f34, Decl(keyofAndIndexedAccess.ts, 155, 1)) +>ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 157, 13)) +>TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 5, 1)) let tag1 = f33(ts, "tag"); ->tag1 : Symbol(tag1, Decl(keyofAndIndexedAccess.ts, 159, 7)) ->f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 150, 1)) ->ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 158, 13)) +>tag1 : Symbol(tag1, Decl(keyofAndIndexedAccess.ts, 158, 7)) +>f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 149, 1)) +>ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 157, 13)) let tag2 = getProperty(ts, "tag"); ->tag2 : Symbol(tag2, Decl(keyofAndIndexedAccess.ts, 160, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 158, 13)) +>tag2 : Symbol(tag2, Decl(keyofAndIndexedAccess.ts, 159, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 157, 13)) } class C { ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) public x: string; ->x : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 163, 9)) +>x : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 162, 9)) protected y: string; ->y : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 164, 21)) +>y : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 163, 21)) private z: string; ->z : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 165, 24)) +>z : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 164, 24)) } // Indexed access expressions have always permitted access to private and protected members. // For consistency we also permit such access in indexed access types. function f40(c: C) { ->f40 : Symbol(f40, Decl(keyofAndIndexedAccess.ts, 167, 1)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>f40 : Symbol(f40, Decl(keyofAndIndexedAccess.ts, 166, 1)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) type X = C["x"]; ->X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 171, 20)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 170, 20)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) type Y = C["y"]; ->Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 172, 20)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 171, 20)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) type Z = C["z"]; ->Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 173, 20)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 172, 20)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) let x: X = c["x"]; ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 175, 7)) ->X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 171, 20)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->"x" : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 163, 9)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 174, 7)) +>X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 170, 20)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>"x" : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 162, 9)) let y: Y = c["y"]; ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 176, 7)) ->Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 172, 20)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->"y" : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 164, 21)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 175, 7)) +>Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 171, 20)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>"y" : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 163, 21)) let z: Z = c["z"]; ->z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 177, 7)) ->Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 173, 20)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->"z" : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 165, 24)) +>z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 176, 7)) +>Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 172, 20)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>"z" : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 164, 24)) } function f50(k: keyof T, s: string) { ->f50 : Symbol(f50, Decl(keyofAndIndexedAccess.ts, 178, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 180, 13)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 180, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 180, 13)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 180, 27)) +>f50 : Symbol(f50, Decl(keyofAndIndexedAccess.ts, 177, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 179, 13)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 179, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 179, 13)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 179, 27)) const x1 = s as keyof T; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 181, 9)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 180, 27)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 180, 13)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 180, 9)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 179, 27)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 179, 13)) const x2 = k as string; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 182, 9)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 180, 16)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 181, 9)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 179, 16)) } function f51(k: K, s: string) { ->f51 : Symbol(f51, Decl(keyofAndIndexedAccess.ts, 183, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 185, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 185, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 185, 13)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 185, 35)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 185, 15)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 185, 40)) +>f51 : Symbol(f51, Decl(keyofAndIndexedAccess.ts, 182, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 184, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 184, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 184, 13)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 184, 35)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 184, 15)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 184, 40)) const x1 = s as keyof T; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 186, 9)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 185, 40)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 185, 13)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 185, 9)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 184, 40)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 184, 13)) const x2 = k as string; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 187, 9)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 185, 35)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 186, 9)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 184, 35)) } function f52(obj: { [x: string]: boolean }, k: keyof T, s: string, n: number) { ->f52 : Symbol(f52, Decl(keyofAndIndexedAccess.ts, 188, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 190, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 190, 24)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 190, 46)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 190, 13)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 190, 58)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 190, 69)) +>f52 : Symbol(f52, Decl(keyofAndIndexedAccess.ts, 187, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 189, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 189, 24)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 189, 46)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 189, 13)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 189, 58)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 189, 69)) const x1 = obj[s]; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 191, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 190, 58)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 190, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 189, 58)) const x2 = obj[n]; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 192, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 190, 69)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 191, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 189, 69)) const x3 = obj[k]; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 193, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 190, 46)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 192, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 189, 46)) } function f53(obj: { [x: string]: boolean }, k: K, s: string, n: number) { ->f53 : Symbol(f53, Decl(keyofAndIndexedAccess.ts, 194, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 196, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 196, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 196, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 196, 43)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 196, 65)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 196, 15)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 196, 71)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 196, 82)) +>f53 : Symbol(f53, Decl(keyofAndIndexedAccess.ts, 193, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 195, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 195, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 195, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 195, 43)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 195, 65)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 195, 15)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 195, 71)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 195, 82)) const x1 = obj[s]; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 197, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 196, 71)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 196, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 195, 71)) const x2 = obj[n]; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 198, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 196, 82)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 197, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 195, 82)) const x3 = obj[k]; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 199, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 196, 65)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 198, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 195, 65)) } function f54(obj: T, key: keyof T) { ->f54 : Symbol(f54, Decl(keyofAndIndexedAccess.ts, 200, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 202, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 202, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 202, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 202, 23)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 202, 13)) +>f54 : Symbol(f54, Decl(keyofAndIndexedAccess.ts, 199, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 201, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 201, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 201, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 201, 23)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 201, 13)) for (let s in obj[key]) { ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 203, 12)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 202, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 202, 23)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 202, 12)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 201, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 201, 23)) } const b = "foo" in obj[key]; ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 205, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 202, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 202, 23)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 204, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 201, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 201, 23)) } function f55(obj: T, key: K) { ->f55 : Symbol(f55, Decl(keyofAndIndexedAccess.ts, 206, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 208, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 208, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 208, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 208, 35)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 208, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 208, 42)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 208, 15)) +>f55 : Symbol(f55, Decl(keyofAndIndexedAccess.ts, 205, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 207, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 207, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 207, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 207, 35)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 207, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 207, 42)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 207, 15)) for (let s in obj[key]) { ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 209, 12)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 208, 35)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 208, 42)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 208, 12)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 207, 35)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 207, 42)) } const b = "foo" in obj[key]; ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 211, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 208, 35)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 208, 42)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 210, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 207, 35)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 207, 42)) } function f60(source: T, target: T) { ->f60 : Symbol(f60, Decl(keyofAndIndexedAccess.ts, 212, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 214, 13)) ->source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 214, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 214, 13)) ->target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 214, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 214, 13)) +>f60 : Symbol(f60, Decl(keyofAndIndexedAccess.ts, 211, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 213, 13)) +>source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 213, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 213, 13)) +>target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 213, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 213, 13)) for (let k in source) { ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 215, 12)) ->source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 214, 16)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 214, 12)) +>source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 213, 16)) target[k] = source[k]; ->target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 214, 26)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 215, 12)) ->source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 214, 16)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 215, 12)) +>target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 213, 26)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 214, 12)) +>source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 213, 16)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 214, 12)) } } function f70(func: (k1: keyof (T | U), k2: keyof (T & U)) => void) { ->f70 : Symbol(f70, Decl(keyofAndIndexedAccess.ts, 218, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 220, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 220, 22)) ->k1 : Symbol(k1, Decl(keyofAndIndexedAccess.ts, 220, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 220, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 220, 22)) ->k2 : Symbol(k2, Decl(keyofAndIndexedAccess.ts, 220, 44)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 220, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 220, 22)) +>f70 : Symbol(f70, Decl(keyofAndIndexedAccess.ts, 217, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 219, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 219, 22)) +>k1 : Symbol(k1, Decl(keyofAndIndexedAccess.ts, 219, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 219, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 219, 22)) +>k2 : Symbol(k2, Decl(keyofAndIndexedAccess.ts, 219, 44)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 219, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 219, 22)) func<{ a: any, b: any }, { a: any, c: any }>('a', 'a'); ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 220, 10)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 220, 18)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 220, 30)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 220, 38)) + + func<{ a: any, b: any }, { a: any, c: any }>('a', 'b'); +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 221, 10)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 221, 18)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 221, 30)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 221, 38)) - func<{ a: any, b: any }, { a: any, c: any }>('a', 'b'); ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) + func<{ a: any, b: any }, { a: any, c: any }>('a', 'c'); +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 222, 10)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 222, 18)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 222, 30)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 222, 38)) - - func<{ a: any, b: any }, { a: any, c: any }>('a', 'c'); ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 223, 10)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 223, 18)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 223, 30)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 223, 38)) } function f71(func: (x: T, y: U) => Partial) { ->f71 : Symbol(f71, Decl(keyofAndIndexedAccess.ts, 224, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 226, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 226, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 226, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 226, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 226, 31)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 226, 22)) +>f71 : Symbol(f71, Decl(keyofAndIndexedAccess.ts, 223, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 225, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 225, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 225, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 225, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 225, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 225, 31)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 225, 22)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 226, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 226, 22)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 225, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 225, 22)) let x = func({ a: 1, b: "hello" }, { c: true }); ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 226, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 227, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 227, 24)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 227, 40)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 225, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 226, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 226, 24)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 226, 40)) x.a; // number | undefined >x.a : Symbol(a) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) >a : Symbol(a) x.b; // string | undefined >x.b : Symbol(b) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) >b : Symbol(b) x.c; // boolean | undefined >x.c : Symbol(c) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) >c : Symbol(c) } function f72(func: (x: T, y: U, k: K) => (T & U)[K]) { ->f72 : Symbol(f72, Decl(keyofAndIndexedAccess.ts, 231, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 233, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 233, 55)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 233, 60)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 233, 66)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 233, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 233, 25)) +>f72 : Symbol(f72, Decl(keyofAndIndexedAccess.ts, 230, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 232, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 232, 55)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 232, 60)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 232, 66)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 232, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 232, 25)) let a = func({ a: 1, b: "hello" }, { c: true }, 'a'); // number ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 234, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 233, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 233, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 233, 24)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 233, 40)) + + let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 234, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 234, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 234, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 234, 40)) - let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 235, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) + let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 235, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 235, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 235, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 235, 40)) - - let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 236, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 236, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 236, 24)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 236, 40)) } function f73(func: (x: T, y: U, k: K) => (T & U)[K]) { ->f73 : Symbol(f73, Decl(keyofAndIndexedAccess.ts, 237, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 239, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 239, 51)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 239, 56)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 239, 62)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 239, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 239, 25)) +>f73 : Symbol(f73, Decl(keyofAndIndexedAccess.ts, 236, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 238, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 238, 51)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 238, 56)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 238, 62)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 238, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 238, 25)) let a = func({ a: 1, b: "hello" }, { c: true }, 'a'); // number ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 240, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 239, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 239, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 239, 24)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 239, 40)) + + let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 240, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 240, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 240, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 240, 40)) - let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 241, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) + let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 241, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 241, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 241, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 241, 40)) - - let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 242, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 242, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 242, 24)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 242, 40)) } function f74(func: (x: T, y: U, k: K) => (T | U)[K]) { ->f74 : Symbol(f74, Decl(keyofAndIndexedAccess.ts, 243, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 245, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 245, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 245, 51)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 245, 56)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 245, 62)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 245, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 245, 25)) +>f74 : Symbol(f74, Decl(keyofAndIndexedAccess.ts, 242, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 244, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 244, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 244, 51)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 244, 56)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 244, 62)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 244, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 244, 25)) let a = func({ a: 1, b: "hello" }, { a: 2, b: true }, 'a'); // number ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 246, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 245, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 245, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 244, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 245, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 245, 24)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 245, 40)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 245, 46)) + + let b = func({ a: 1, b: "hello" }, { a: 2, b: true }, 'b'); // string | boolean +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 246, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 244, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 246, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 246, 24)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 246, 40)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 246, 46)) - - let b = func({ a: 1, b: "hello" }, { a: 2, b: true }, 'b'); // string | boolean ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 247, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 245, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 247, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 247, 24)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 247, 40)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 247, 46)) } function f80(obj: T) { ->f80 : Symbol(f80, Decl(keyofAndIndexedAccess.ts, 248, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) +>f80 : Symbol(f80, Decl(keyofAndIndexedAccess.ts, 247, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) let a1 = obj.a; // { x: any } ->a1 : Symbol(a1, Decl(keyofAndIndexedAccess.ts, 251, 7)) ->obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) +>a1 : Symbol(a1, Decl(keyofAndIndexedAccess.ts, 250, 7)) +>obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) let a2 = obj['a']; // { x: any } ->a2 : Symbol(a2, Decl(keyofAndIndexedAccess.ts, 252, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) +>a2 : Symbol(a2, Decl(keyofAndIndexedAccess.ts, 251, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) let a3 = obj['a'] as T['a']; // T["a"] ->a3 : Symbol(a3, Decl(keyofAndIndexedAccess.ts, 253, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) +>a3 : Symbol(a3, Decl(keyofAndIndexedAccess.ts, 252, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) let x1 = obj.a.x; // any ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 254, 7)) ->obj.a.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) ->obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 253, 7)) +>obj.a.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) +>obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) let x2 = obj['a']['x']; // any ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 255, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 254, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) let x3 = obj['a']['x'] as T['a']['x']; // T["a"]["x"] ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 256, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 255, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) } function f81(obj: T) { ->f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 257, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 259, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 259, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 259, 29)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 259, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 259, 13)) +>f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 256, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 258, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 258, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 258, 29)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 258, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 258, 13)) return obj['a']['x'] as T['a']['x']; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 259, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 259, 24)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 259, 29)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 259, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 258, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 258, 24)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 258, 29)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 258, 13)) } function f82() { ->f82 : Symbol(f82, Decl(keyofAndIndexedAccess.ts, 261, 1)) +>f82 : Symbol(f82, Decl(keyofAndIndexedAccess.ts, 260, 1)) let x1 = f81({ a: { x: "hello" } }); // string ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 264, 7)) ->f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 257, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 264, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 264, 23)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 263, 7)) +>f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 256, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 263, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 263, 23)) let x2 = f81({ a: { x: 42 } }); // number ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 265, 7)) ->f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 257, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 265, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 265, 23)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 264, 7)) +>f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 256, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 264, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 264, 23)) } function f83(obj: T, key: K) { ->f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 266, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 268, 26)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 268, 39)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 268, 51)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 268, 71)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 268, 78)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 268, 51)) +>f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 265, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 267, 26)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 267, 39)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 267, 51)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 267, 71)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 267, 78)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 267, 51)) return obj[key]['x'] as T[K]['x']; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 268, 71)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 268, 78)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 268, 39)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 268, 51)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 267, 71)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 267, 78)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 267, 39)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 267, 51)) } function f84() { ->f84 : Symbol(f84, Decl(keyofAndIndexedAccess.ts, 270, 1)) +>f84 : Symbol(f84, Decl(keyofAndIndexedAccess.ts, 269, 1)) let x1 = f83({ foo: { x: "hello" } }, "foo"); // string ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 273, 7)) ->f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 266, 1)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 273, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 273, 25)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 272, 7)) +>f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 265, 1)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 272, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 272, 25)) let x2 = f83({ bar: { x: 42 } }, "bar"); // number ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 274, 7)) ->f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 266, 1)) ->bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 274, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 274, 25)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 273, 7)) +>f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 265, 1)) +>bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 273, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 273, 25)) } class C1 { ->C1 : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) +>C1 : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) x: number; ->x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) get(key: K) { ->get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 278, 14)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 279, 8)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 279, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 279, 8)) +>get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 277, 14)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 278, 8)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 278, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 278, 8)) return this[key]; ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 279, 30)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 278, 30)) } set(key: K, value: this[K]) { ->set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 281, 5)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 282, 8)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 282, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 282, 8)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 282, 37)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 282, 8)) +>set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 280, 5)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 281, 8)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 281, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 281, 8)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 281, 37)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 281, 8)) this[key] = value; ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 282, 30)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 282, 37)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 281, 30)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 281, 37)) } foo() { ->foo : Symbol(C1.foo, Decl(keyofAndIndexedAccess.ts, 284, 5)) +>foo : Symbol(C1.foo, Decl(keyofAndIndexedAccess.ts, 283, 5)) let x1 = this.x; // number ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 286, 11)) ->this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 285, 11)) +>this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) let x2 = this["x"]; // number ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 287, 11)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 286, 11)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) let x3 = this.get("x"); // this["x"] ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 288, 11)) ->this.get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 278, 14)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 278, 14)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 287, 11)) +>this.get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 277, 14)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 277, 14)) let x4 = getProperty(this, "x"); // this["x"] ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 289, 11)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 288, 11)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) this.x = 42; ->this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) this["x"] = 42; ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) this.set("x", 42); ->this.set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 281, 5)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 281, 5)) +>this.set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 280, 5)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 280, 5)) setProperty(this, "x", 42); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) } } type S2 = { ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) a: string; ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 297, 11)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 296, 11)) b: string; ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 298, 14)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 297, 14)) }; function f90(x1: S2[keyof S2], x2: T[keyof S2], x3: S2[K], x4: T[K]) { ->f90 : Symbol(f90, Decl(keyofAndIndexedAccess.ts, 300, 2)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 302, 13)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 302, 26)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 302, 13)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 302, 26)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 302, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 302, 26)) +>f90 : Symbol(f90, Decl(keyofAndIndexedAccess.ts, 299, 2)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 301, 13)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 301, 26)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 301, 13)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 301, 26)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 301, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 301, 26)) x1 = x2; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) x1 = x3; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) x1 = x4; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) x2 = x1; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) x2 = x3; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) x2 = x4; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) x3 = x1; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) x3 = x2; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) x3 = x4; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) x4 = x1; ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) x4 = x2; ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) x4 = x3; ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) x1.length; >x1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) x2.length; >x2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) x3.length; >x3.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) x4.length; >x4.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Repros from #12011 class Base { ->Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) +>Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) get(prop: K) { ->get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 323, 12)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 324, 8)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 324, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 324, 8)) +>get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 322, 12)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 323, 8)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 323, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 323, 8)) return this[prop]; ->this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 324, 30)) +>this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 323, 30)) } set(prop: K, value: this[K]) { ->set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 326, 5)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 327, 8)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 327, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 327, 8)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 327, 38)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 327, 8)) +>set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 325, 5)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 326, 8)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 326, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 326, 8)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 326, 38)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 326, 8)) this[prop] = value; ->this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 327, 30)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 327, 38)) +>this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 326, 30)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 326, 38)) } } class Person extends Base { ->Person : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 330, 1)) ->Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) +>Person : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 329, 1)) +>Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) parts: number; ->parts : Symbol(Person.parts, Decl(keyofAndIndexedAccess.ts, 332, 27)) +>parts : Symbol(Person.parts, Decl(keyofAndIndexedAccess.ts, 331, 27)) constructor(parts: number) { ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 334, 16)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 333, 16)) super(); ->super : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) +>super : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) this.set("parts", parts); ->this.set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 326, 5)) ->this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 330, 1)) ->set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 326, 5)) ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 334, 16)) +>this.set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 325, 5)) +>this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 329, 1)) +>set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 325, 5)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 333, 16)) } getParts() { ->getParts : Symbol(Person.getParts, Decl(keyofAndIndexedAccess.ts, 337, 5)) +>getParts : Symbol(Person.getParts, Decl(keyofAndIndexedAccess.ts, 336, 5)) return this.get("parts") ->this.get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 323, 12)) ->this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 330, 1)) ->get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 323, 12)) +>this.get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 322, 12)) +>this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 329, 1)) +>get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 322, 12)) } } class OtherPerson { ->OtherPerson : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 341, 1)) +>OtherPerson : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 340, 1)) parts: number; ->parts : Symbol(OtherPerson.parts, Decl(keyofAndIndexedAccess.ts, 343, 19)) +>parts : Symbol(OtherPerson.parts, Decl(keyofAndIndexedAccess.ts, 342, 19)) constructor(parts: number) { ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 345, 16)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 344, 16)) setProperty(this, "parts", parts); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 341, 1)) ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 345, 16)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 340, 1)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 344, 16)) } getParts() { ->getParts : Symbol(OtherPerson.getParts, Decl(keyofAndIndexedAccess.ts, 347, 5)) +>getParts : Symbol(OtherPerson.getParts, Decl(keyofAndIndexedAccess.ts, 346, 5)) return getProperty(this, "parts") ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 341, 1)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 340, 1)) } } // Modified repro from #12544 function path(obj: T, key1: K1): T[K1]; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 355, 37)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 355, 44)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 354, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 354, 37)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 354, 44)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 354, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 354, 16)) function path(obj: T, key1: K1, key2: K2): T[K1][K2]; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 356, 61)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 356, 68)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 356, 78)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 355, 36)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 355, 61)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 355, 68)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 355, 78)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 355, 36)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 355, 36)) function path(obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3]; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 357, 60)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 357, 89)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 357, 96)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 357, 106)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->key3 : Symbol(key3, Decl(keyofAndIndexedAccess.ts, 357, 116)) ->K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 357, 60)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 357, 60)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 356, 60)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 356, 89)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 356, 96)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 356, 106)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>key3 : Symbol(key3, Decl(keyofAndIndexedAccess.ts, 356, 116)) +>K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 356, 60)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 356, 60)) function path(obj: any, ...keys: (string | number)[]): any; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 357, 14)) +>keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 357, 23)) + +function path(obj: any, ...keys: (string | number)[]): any { +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) >obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 358, 14)) >keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 358, 23)) -function path(obj: any, ...keys: (string | number)[]): any { ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 359, 14)) ->keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 359, 23)) - let result = obj; ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 359, 14)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 358, 14)) for (let k of keys) { ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 361, 12)) ->keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 359, 23)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 360, 12)) +>keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 358, 23)) result = result[k]; ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 361, 12)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 360, 12)) } return result; ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) } type Thing = { ->Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 365, 1)) +>Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 364, 1)) a: { x: number, y: string }, ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 367, 14)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 368, 8)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 368, 19)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 366, 14)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 367, 8)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 367, 19)) b: boolean ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 368, 32)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 367, 32)) }; function f1(thing: Thing) { ->f1 : Symbol(f1, Decl(keyofAndIndexedAccess.ts, 370, 2)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) ->Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 365, 1)) +>f1 : Symbol(f1, Decl(keyofAndIndexedAccess.ts, 369, 2)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) +>Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 364, 1)) let x1 = path(thing, 'a'); // { x: number, y: string } ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 374, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 373, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) let x2 = path(thing, 'a', 'y'); // string ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 375, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 374, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) let x3 = path(thing, 'b'); // boolean ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 376, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 375, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) let x4 = path(thing, ...['a', 'x']); // any ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 377, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 376, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) } // Repro from comment in #12114 const assignTo2 = (object: T, key1: K1, key2: K2) => ->assignTo2 : Symbol(assignTo2, Decl(keyofAndIndexedAccess.ts, 382, 5)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 382, 41)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 382, 66)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 382, 76)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 382, 86)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 382, 41)) +>assignTo2 : Symbol(assignTo2, Decl(keyofAndIndexedAccess.ts, 381, 5)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 381, 41)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 381, 66)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 381, 76)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 381, 86)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 381, 41)) (value: T[K1][K2]) => object[key1][key2] = value; ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 383, 5)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 382, 41)) ->object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 382, 66)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 382, 76)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 382, 86)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 383, 5)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 382, 5)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 381, 41)) +>object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 381, 66)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 381, 76)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 381, 86)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 382, 5)) // Modified repro from #12573 declare function one(handler: (t: T) => void): T ->one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 383, 53)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 387, 21)) ->handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 387, 24)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 387, 34)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 387, 21)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 387, 21)) +>one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 382, 53)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 386, 21)) +>handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 386, 24)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 386, 34)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 386, 21)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 386, 21)) var empty = one(() => {}) // inferred as {}, expected ->empty : Symbol(empty, Decl(keyofAndIndexedAccess.ts, 388, 3)) ->one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 383, 53)) +>empty : Symbol(empty, Decl(keyofAndIndexedAccess.ts, 387, 3)) +>one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 382, 53)) type Handlers = { [K in keyof T]: (t: T[K]) => void } ->Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 388, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 14)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 390, 22)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 14)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 390, 38)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 14)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 390, 22)) +>Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 387, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 389, 14)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 389, 22)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 389, 14)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 389, 38)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 389, 14)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 389, 22)) declare function on(handlerHash: Handlers): T ->on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 390, 56)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 391, 20)) ->handlerHash : Symbol(handlerHash, Decl(keyofAndIndexedAccess.ts, 391, 23)) ->Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 388, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 391, 20)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 391, 20)) +>on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 389, 56)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 20)) +>handlerHash : Symbol(handlerHash, Decl(keyofAndIndexedAccess.ts, 390, 23)) +>Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 387, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 20)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 20)) var hashOfEmpty1 = on({ test: () => {} }); // {} ->hashOfEmpty1 : Symbol(hashOfEmpty1, Decl(keyofAndIndexedAccess.ts, 392, 3)) ->on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 390, 56)) ->test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 392, 23)) +>hashOfEmpty1 : Symbol(hashOfEmpty1, Decl(keyofAndIndexedAccess.ts, 391, 3)) +>on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 389, 56)) +>test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 391, 23)) var hashOfEmpty2 = on({ test: (x: boolean) => {} }); // { test: boolean } ->hashOfEmpty2 : Symbol(hashOfEmpty2, Decl(keyofAndIndexedAccess.ts, 393, 3)) ->on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 390, 56)) ->test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 393, 23)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 393, 31)) +>hashOfEmpty2 : Symbol(hashOfEmpty2, Decl(keyofAndIndexedAccess.ts, 392, 3)) +>on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 389, 56)) +>test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 392, 23)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 392, 31)) // Repro from #12624 interface Options1 { ->Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 393, 52)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 397, 19)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 397, 24)) +>Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 392, 52)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 396, 19)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 396, 24)) data?: Data ->data : Symbol(Options1.data, Decl(keyofAndIndexedAccess.ts, 397, 36)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 397, 19)) +>data : Symbol(Options1.data, Decl(keyofAndIndexedAccess.ts, 396, 36)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 396, 19)) computed?: Computed; ->computed : Symbol(Options1.computed, Decl(keyofAndIndexedAccess.ts, 398, 15)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 397, 24)) +>computed : Symbol(Options1.computed, Decl(keyofAndIndexedAccess.ts, 397, 15)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 396, 24)) } declare class Component1 { ->Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 400, 1)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) +>Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 399, 1)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) constructor(options: Options1); ->options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 403, 16)) ->Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 393, 52)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) +>options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 402, 16)) +>Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 392, 52)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) get(key: K): (Data & Computed)[K]; ->get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 403, 51)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 404, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 404, 43)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 404, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 404, 8)) +>get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 402, 51)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 403, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 403, 43)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 403, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 403, 8)) } let c1 = new Component1({ ->c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 407, 3)) ->Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 400, 1)) +>c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 406, 3)) +>Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 399, 1)) data: { ->data : Symbol(data, Decl(keyofAndIndexedAccess.ts, 407, 25)) +>data : Symbol(data, Decl(keyofAndIndexedAccess.ts, 406, 25)) hello: "" ->hello : Symbol(hello, Decl(keyofAndIndexedAccess.ts, 408, 11)) +>hello : Symbol(hello, Decl(keyofAndIndexedAccess.ts, 407, 11)) } }); c1.get("hello"); ->c1.get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 403, 51)) ->c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 407, 3)) ->get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 403, 51)) +>c1.get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 402, 51)) +>c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 406, 3)) +>get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 402, 51)) // Repro from #12625 interface Options2 { ->Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 413, 16)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 417, 19)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 417, 24)) +>Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 412, 16)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 416, 19)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 416, 24)) data?: Data ->data : Symbol(Options2.data, Decl(keyofAndIndexedAccess.ts, 417, 36)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 417, 19)) +>data : Symbol(Options2.data, Decl(keyofAndIndexedAccess.ts, 416, 36)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 416, 19)) computed?: Computed; ->computed : Symbol(Options2.computed, Decl(keyofAndIndexedAccess.ts, 418, 15)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 417, 24)) +>computed : Symbol(Options2.computed, Decl(keyofAndIndexedAccess.ts, 417, 15)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 416, 24)) } declare class Component2 { ->Component2 : Symbol(Component2, Decl(keyofAndIndexedAccess.ts, 420, 1)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) +>Component2 : Symbol(Component2, Decl(keyofAndIndexedAccess.ts, 419, 1)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) constructor(options: Options2); ->options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 423, 16)) ->Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 413, 16)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) +>options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 422, 16)) +>Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 412, 16)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) get(key: K): (Data & Computed)[K]; ->get : Symbol(Component2.get, Decl(keyofAndIndexedAccess.ts, 423, 51)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 424, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 424, 47)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 424, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 424, 8)) +>get : Symbol(Component2.get, Decl(keyofAndIndexedAccess.ts, 422, 51)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 423, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 423, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 423, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 423, 8)) } // Repro from #12641 interface R { ->R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 425, 1)) +>R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 424, 1)) p: number; ->p : Symbol(R.p, Decl(keyofAndIndexedAccess.ts, 429, 13)) +>p : Symbol(R.p, Decl(keyofAndIndexedAccess.ts, 428, 13)) } function f(p: K) { ->f : Symbol(f, Decl(keyofAndIndexedAccess.ts, 431, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 433, 11)) ->R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 425, 1)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 433, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 433, 11)) +>f : Symbol(f, Decl(keyofAndIndexedAccess.ts, 430, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 432, 11)) +>R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 424, 1)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 432, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 432, 11)) let a: any; ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 434, 7)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 433, 7)) a[p].add; // any ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 434, 7)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 433, 30)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 433, 7)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 432, 30)) } // Repro from #12651 type MethodDescriptor = { ->MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 436, 1)) +>MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 435, 1)) name: string; ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 440, 25)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 439, 25)) args: any[]; ->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 441, 14)) +>args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 440, 14)) returnValue: any; ->returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 442, 13)) +>returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 441, 13)) } declare function dispatchMethod(name: M['name'], args: M['args']): M['returnValue']; ->dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 444, 1)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) ->MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 436, 1)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 446, 60)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) ->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 446, 76)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) +>dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 443, 1)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) +>MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 435, 1)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 445, 60)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) +>args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 445, 76)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) type SomeMethodDescriptor = { ->SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 446, 112)) +>SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 445, 112)) name: "someMethod"; ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 448, 29)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 447, 29)) args: [string, number]; ->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 449, 20)) +>args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 448, 20)) returnValue: string[]; ->returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 450, 24)) +>returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 449, 24)) } let result = dispatchMethod("someMethod", ["hello", 35]); ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 454, 3)) ->dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 444, 1)) ->SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 446, 112)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 453, 3)) +>dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 443, 1)) +>SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 445, 112)) // Repro from #13073 type KeyTypes = "a" | "b" ->KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 454, 79)) +>KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 453, 79)) let MyThingy: { [key in KeyTypes]: string[] }; ->MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 459, 3)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 459, 17)) ->KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 454, 79)) +>MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 458, 3)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 458, 17)) +>KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 453, 79)) function addToMyThingy(key: S) { ->addToMyThingy : Symbol(addToMyThingy, Decl(keyofAndIndexedAccess.ts, 459, 46)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 461, 23)) ->KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 454, 79)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 461, 43)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 461, 23)) +>addToMyThingy : Symbol(addToMyThingy, Decl(keyofAndIndexedAccess.ts, 458, 46)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 460, 23)) +>KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 453, 79)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 460, 43)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 460, 23)) MyThingy[key].push("a"); >MyThingy[key].push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 459, 3)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 461, 43)) +>MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 458, 3)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 460, 43)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } // Repro from #13102 type Handler = { ->Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 463, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 467, 13)) +>Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 462, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 466, 13)) onChange: (name: keyof T) => void; ->onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 467, 19)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 468, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 467, 13)) +>onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 466, 19)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 467, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 466, 13)) }; function onChangeGenericFunction(handler: Handler) { ->onChangeGenericFunction : Symbol(onChangeGenericFunction, Decl(keyofAndIndexedAccess.ts, 469, 2)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 471, 33)) ->handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 471, 36)) ->Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 463, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 471, 33)) ->preset : Symbol(preset, Decl(keyofAndIndexedAccess.ts, 471, 58)) +>onChangeGenericFunction : Symbol(onChangeGenericFunction, Decl(keyofAndIndexedAccess.ts, 468, 2)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 470, 33)) +>handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 470, 36)) +>Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 462, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 470, 33)) +>preset : Symbol(preset, Decl(keyofAndIndexedAccess.ts, 470, 58)) handler.onChange('preset') ->handler.onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 467, 19)) ->handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 471, 36)) ->onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 467, 19)) +>handler.onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 466, 19)) +>handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 470, 36)) +>onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 466, 19)) } // Repro from #13285 function updateIds, K extends string>( ->updateIds : Symbol(updateIds, Decl(keyofAndIndexedAccess.ts, 473, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 477, 19)) +>updateIds : Symbol(updateIds, Decl(keyofAndIndexedAccess.ts, 472, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 476, 19)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) obj: T, ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 477, 19)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 476, 19)) idFields: K[], ->idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 478, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) +>idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 477, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) idMapping: { [oldId: string]: string } ->idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 479, 18)) ->oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 480, 18)) +>idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 478, 18)) +>oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 479, 18)) ): Record { >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) for (const idField of idFields) { ->idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 482, 14)) ->idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 478, 11)) +>idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 481, 14)) +>idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 477, 11)) const newId = idMapping[obj[idField]]; ->newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 483, 13)) ->idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 479, 18)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) ->idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 482, 14)) +>newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 482, 13)) +>idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 478, 18)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) +>idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 481, 14)) if (newId) { ->newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 483, 13)) +>newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 482, 13)) obj[idField] = newId; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) ->idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 482, 14)) ->newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 483, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) +>idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 481, 14)) +>newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 482, 13)) } } return obj; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) } // Repro from #13285 function updateIds2( ->updateIds2 : Symbol(updateIds2, Decl(keyofAndIndexedAccess.ts, 489, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 493, 20)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 493, 33)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 493, 54)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 493, 20)) +>updateIds2 : Symbol(updateIds2, Decl(keyofAndIndexedAccess.ts, 488, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 492, 20)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 492, 33)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 492, 54)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 492, 20)) obj: T, ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 493, 74)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 493, 20)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 492, 74)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 492, 20)) key: K, ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 494, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 493, 54)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 493, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 492, 54)) stringMap: { [oldId: string]: string } ->stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 495, 11)) ->oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 496, 18)) +>stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 494, 11)) +>oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 495, 18)) ) { var x = obj[key]; ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 498, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 493, 74)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 494, 11)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 497, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 492, 74)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 493, 11)) stringMap[x]; // Should be OK. ->stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 495, 11)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 498, 7)) +>stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 494, 11)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 497, 7)) } // Repro from #13514 declare function head>(list: T): T[0]; ->head : Symbol(head, Decl(keyofAndIndexedAccess.ts, 500, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22)) +>head : Symbol(head, Decl(keyofAndIndexedAccess.ts, 499, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 503, 22)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->list : Symbol(list, Decl(keyofAndIndexedAccess.ts, 504, 44)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22)) +>list : Symbol(list, Decl(keyofAndIndexedAccess.ts, 503, 44)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 503, 22)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 503, 22)) // Repro from #13604 class A { ->A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 504, 59)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 508, 8)) +>A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 503, 59)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 507, 8)) props: T & { foo: string }; ->props : Symbol(A.props, Decl(keyofAndIndexedAccess.ts, 508, 12)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 508, 8)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 509, 13)) +>props : Symbol(A.props, Decl(keyofAndIndexedAccess.ts, 507, 12)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 507, 8)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 508, 13)) } class B extends A<{ x: number}> { ->B : Symbol(B, Decl(keyofAndIndexedAccess.ts, 510, 1)) ->A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 504, 59)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19)) +>B : Symbol(B, Decl(keyofAndIndexedAccess.ts, 509, 1)) +>A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 503, 59)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 511, 19)) f(p: this["props"]) { ->f : Symbol(B.f, Decl(keyofAndIndexedAccess.ts, 512, 33)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 513, 3)) +>f : Symbol(B.f, Decl(keyofAndIndexedAccess.ts, 511, 33)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 512, 3)) p.x; ->p.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 513, 3)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19)) +>p.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 511, 19)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 512, 3)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 511, 19)) } } // Repro from #13749 class Form { ->Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) +>Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 515, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) private childFormFactories: {[K in keyof T]: (v: T[K]) => Form} ->childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->v : Symbol(v, Decl(keyofAndIndexedAccess.ts, 521, 50)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34)) ->Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34)) +>childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 519, 15)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 520, 34)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>v : Symbol(v, Decl(keyofAndIndexedAccess.ts, 520, 50)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 520, 34)) +>Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 515, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 520, 34)) public set(prop: K, value: T[K]) { ->set : Symbol(Form.set, Decl(keyofAndIndexedAccess.ts, 521, 73)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 523, 34)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 523, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15)) +>set : Symbol(Form.set, Decl(keyofAndIndexedAccess.ts, 520, 73)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 522, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 522, 34)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 522, 15)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 522, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 522, 15)) this.childFormFactories[prop](value) ->this.childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15)) ->this : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1)) ->childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 523, 34)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 523, 42)) +>this.childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 519, 15)) +>this : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 515, 1)) +>childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 519, 15)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 522, 34)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 522, 42)) } } // Repro from #13787 class SampleClass

{ ->SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18)) +>SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 529, 18)) public props: Readonly

; ->props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) +>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18)) +>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 529, 18)) constructor(props: P) { ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 532, 16)) ->P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 531, 16)) +>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 529, 18)) this.props = Object.freeze(props); ->this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) ->this : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) +>this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) +>this : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) >Object.freeze : Symbol(ObjectConstructor.freeze, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >freeze : Symbol(ObjectConstructor.freeze, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 532, 16)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 531, 16)) } } interface Foo { ->Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1)) +>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 534, 1)) foo: string; ->foo : Symbol(Foo.foo, Decl(keyofAndIndexedAccess.ts, 537, 15)) +>foo : Symbol(Foo.foo, Decl(keyofAndIndexedAccess.ts, 536, 15)) } declare function merge(obj1: T, obj2: U): T & U; ->merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 539, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25)) ->obj1 : Symbol(obj1, Decl(keyofAndIndexedAccess.ts, 541, 29)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23)) ->obj2 : Symbol(obj2, Decl(keyofAndIndexedAccess.ts, 541, 37)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25)) +>merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 538, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 540, 23)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 540, 25)) +>obj1 : Symbol(obj1, Decl(keyofAndIndexedAccess.ts, 540, 29)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 540, 23)) +>obj2 : Symbol(obj2, Decl(keyofAndIndexedAccess.ts, 540, 37)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 540, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 540, 23)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 540, 25)) class AnotherSampleClass extends SampleClass { ->AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25)) ->SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25)) ->Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1)) +>AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 540, 54)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 542, 25)) +>SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 542, 25)) +>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 534, 1)) constructor(props: T) { ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 544, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 543, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 542, 25)) const foo: Foo = { foo: "bar" }; ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 13)) ->Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 544, 13)) +>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 534, 1)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 544, 26)) super(merge(props, foo)); ->super : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 539, 1)) ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 544, 16)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 13)) +>super : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 538, 1)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 543, 16)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 544, 13)) } public brokenMethod() { ->brokenMethod : Symbol(AnotherSampleClass.brokenMethod, Decl(keyofAndIndexedAccess.ts, 547, 5)) +>brokenMethod : Symbol(AnotherSampleClass.brokenMethod, Decl(keyofAndIndexedAccess.ts, 546, 5)) this.props.foo.concat; >this.props.foo.concat : Symbol(String.concat, Decl(lib.d.ts, --, --)) >this.props.foo : Symbol(foo) ->this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) ->this : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54)) ->props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) +>this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) +>this : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 540, 54)) +>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) >foo : Symbol(foo) >concat : Symbol(String.concat, Decl(lib.d.ts, --, --)) } } new AnotherSampleClass({}); ->AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54)) +>AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 540, 54)) diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types index 86469efc284..7f7cd11f708 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.types +++ b/tests/baselines/reference/keyofAndIndexedAccess.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts === - class Shape { >Shape : Shape diff --git a/tests/baselines/reference/keywordInJsxIdentifier.js b/tests/baselines/reference/keywordInJsxIdentifier.js index d9c3b51e9a3..f88fe4dff87 100644 --- a/tests/baselines/reference/keywordInJsxIdentifier.js +++ b/tests/baselines/reference/keywordInJsxIdentifier.js @@ -1,5 +1,4 @@ //// [keywordInJsxIdentifier.tsx] - declare var React: any; ; ; diff --git a/tests/baselines/reference/keywordInJsxIdentifier.symbols b/tests/baselines/reference/keywordInJsxIdentifier.symbols index 73ee7376164..b56f0af3285 100644 --- a/tests/baselines/reference/keywordInJsxIdentifier.symbols +++ b/tests/baselines/reference/keywordInJsxIdentifier.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/keywordInJsxIdentifier.tsx === - declare var React: any; ->React : Symbol(React, Decl(keywordInJsxIdentifier.tsx, 1, 11)) +>React : Symbol(React, Decl(keywordInJsxIdentifier.tsx, 0, 11)) ; >foo : Symbol(unknown) ->class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 2, 4)) +>class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 1, 4)) ; >foo : Symbol(unknown) ->class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 3, 4)) +>class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 2, 4)) ; >foo : Symbol(unknown) ->class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 4, 4)) +>class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 3, 4)) ; >foo : Symbol(unknown) ->class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 5, 4)) +>class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 4, 4)) diff --git a/tests/baselines/reference/keywordInJsxIdentifier.types b/tests/baselines/reference/keywordInJsxIdentifier.types index 0e4c4387cf4..09ae09340de 100644 --- a/tests/baselines/reference/keywordInJsxIdentifier.types +++ b/tests/baselines/reference/keywordInJsxIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/keywordInJsxIdentifier.tsx === - declare var React: any; >React : any diff --git a/tests/baselines/reference/lambdaASIEmit.js b/tests/baselines/reference/lambdaASIEmit.js index 49672b75c7c..b60c772cf1e 100644 --- a/tests/baselines/reference/lambdaASIEmit.js +++ b/tests/baselines/reference/lambdaASIEmit.js @@ -1,5 +1,4 @@ //// [lambdaASIEmit.ts] - function Foo(x: any) { } diff --git a/tests/baselines/reference/lambdaASIEmit.symbols b/tests/baselines/reference/lambdaASIEmit.symbols index d33cc16817a..d57bbf60a7f 100644 --- a/tests/baselines/reference/lambdaASIEmit.symbols +++ b/tests/baselines/reference/lambdaASIEmit.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/lambdaASIEmit.ts === - function Foo(x: any) >Foo : Symbol(Foo, Decl(lambdaASIEmit.ts, 0, 0)) ->x : Symbol(x, Decl(lambdaASIEmit.ts, 1, 13)) +>x : Symbol(x, Decl(lambdaASIEmit.ts, 0, 13)) { } diff --git a/tests/baselines/reference/lambdaASIEmit.types b/tests/baselines/reference/lambdaASIEmit.types index 381e45c5fd2..2f9db646ebb 100644 --- a/tests/baselines/reference/lambdaASIEmit.types +++ b/tests/baselines/reference/lambdaASIEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/lambdaASIEmit.ts === - function Foo(x: any) >Foo : (x: any) => void >x : any diff --git a/tests/baselines/reference/letAndVarRedeclaration.errors.txt b/tests/baselines/reference/letAndVarRedeclaration.errors.txt index 50a916e8d90..19f0b8faf8e 100644 --- a/tests/baselines/reference/letAndVarRedeclaration.errors.txt +++ b/tests/baselines/reference/letAndVarRedeclaration.errors.txt @@ -1,29 +1,27 @@ -tests/cases/compiler/letAndVarRedeclaration.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(5,10): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(8,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(9,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(10,14): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(14,9): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(16,13): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(19,18): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(24,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(25,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(26,14): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(30,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(35,18): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(39,5): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(40,10): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(44,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(45,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(50,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(51,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(3,10): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(6,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(7,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(8,14): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(12,9): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(14,13): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(17,18): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(22,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(24,14): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(28,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(30,13): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(33,18): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(37,5): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(38,10): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(42,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(43,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(48,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(49,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. ==== tests/cases/compiler/letAndVarRedeclaration.ts (21 errors) ==== - - let e0 ~~ !!! error TS2451: Cannot redeclare block-scoped variable 'e0'. diff --git a/tests/baselines/reference/letAndVarRedeclaration.js b/tests/baselines/reference/letAndVarRedeclaration.js index eb4dfc9c0e8..a87828f11ff 100644 --- a/tests/baselines/reference/letAndVarRedeclaration.js +++ b/tests/baselines/reference/letAndVarRedeclaration.js @@ -1,6 +1,4 @@ //// [letAndVarRedeclaration.ts] - - let e0 var e0; function e0() { } diff --git a/tests/baselines/reference/letAsIdentifier.errors.txt b/tests/baselines/reference/letAsIdentifier.errors.txt index b4e4db22853..e9b42267dcf 100644 --- a/tests/baselines/reference/letAsIdentifier.errors.txt +++ b/tests/baselines/reference/letAsIdentifier.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letAsIdentifier.ts(3,5): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/letAsIdentifier.ts(6,1): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/letAsIdentifier.ts(2,5): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/letAsIdentifier.ts(5,1): error TS2300: Duplicate identifier 'a'. ==== tests/cases/compiler/letAsIdentifier.ts (2 errors) ==== - var let = 10; var a = 10; ~ diff --git a/tests/baselines/reference/letAsIdentifier.js b/tests/baselines/reference/letAsIdentifier.js index 05811ce1088..98c68154227 100644 --- a/tests/baselines/reference/letAsIdentifier.js +++ b/tests/baselines/reference/letAsIdentifier.js @@ -1,5 +1,4 @@ //// [letAsIdentifier.ts] - var let = 10; var a = 10; let = 30; diff --git a/tests/baselines/reference/letAsIdentifier2.js b/tests/baselines/reference/letAsIdentifier2.js index 62c8461bfc8..ef1568b40cd 100644 --- a/tests/baselines/reference/letAsIdentifier2.js +++ b/tests/baselines/reference/letAsIdentifier2.js @@ -1,5 +1,4 @@ //// [letAsIdentifier2.ts] - function let() {} //// [letAsIdentifier2.js] diff --git a/tests/baselines/reference/letAsIdentifier2.symbols b/tests/baselines/reference/letAsIdentifier2.symbols index 211aae05316..bd0faaf6801 100644 --- a/tests/baselines/reference/letAsIdentifier2.symbols +++ b/tests/baselines/reference/letAsIdentifier2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/letAsIdentifier2.ts === - function let() {} >let : Symbol(let, Decl(letAsIdentifier2.ts, 0, 0)) diff --git a/tests/baselines/reference/letAsIdentifier2.types b/tests/baselines/reference/letAsIdentifier2.types index dc1416fdae9..07ce071011e 100644 --- a/tests/baselines/reference/letAsIdentifier2.types +++ b/tests/baselines/reference/letAsIdentifier2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letAsIdentifier2.ts === - function let() {} >let : () => void diff --git a/tests/baselines/reference/letConstInCaseClauses.errors.txt b/tests/baselines/reference/letConstInCaseClauses.errors.txt index 754da95d367..ae56fe47a79 100644 --- a/tests/baselines/reference/letConstInCaseClauses.errors.txt +++ b/tests/baselines/reference/letConstInCaseClauses.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/letConstInCaseClauses.ts(7,5): error TS2304: Cannot find name 'console'. -tests/cases/compiler/letConstInCaseClauses.ts(21,5): error TS2304: Cannot find name 'console'. -tests/cases/compiler/letConstInCaseClauses.ts(23,14): error TS2678: Type '10' is not comparable to type '1'. -tests/cases/compiler/letConstInCaseClauses.ts(27,14): error TS2678: Type '10' is not comparable to type '2'. +tests/cases/compiler/letConstInCaseClauses.ts(6,5): error TS2304: Cannot find name 'console'. +tests/cases/compiler/letConstInCaseClauses.ts(20,5): error TS2304: Cannot find name 'console'. +tests/cases/compiler/letConstInCaseClauses.ts(22,14): error TS2678: Type '10' is not comparable to type '1'. +tests/cases/compiler/letConstInCaseClauses.ts(26,14): error TS2678: Type '10' is not comparable to type '2'. ==== tests/cases/compiler/letConstInCaseClauses.ts (4 errors) ==== - var x = 10; var y = 20; { diff --git a/tests/baselines/reference/letConstInCaseClauses.js b/tests/baselines/reference/letConstInCaseClauses.js index 33650dcaf4c..0252537cd3e 100644 --- a/tests/baselines/reference/letConstInCaseClauses.js +++ b/tests/baselines/reference/letConstInCaseClauses.js @@ -1,5 +1,4 @@ //// [letConstInCaseClauses.ts] - var x = 10; var y = 20; { diff --git a/tests/baselines/reference/letDeclarations-access.js b/tests/baselines/reference/letDeclarations-access.js index 6ae289d220f..bc792089de0 100644 --- a/tests/baselines/reference/letDeclarations-access.js +++ b/tests/baselines/reference/letDeclarations-access.js @@ -1,5 +1,4 @@ //// [letDeclarations-access.ts] - let x = 0 // No errors diff --git a/tests/baselines/reference/letDeclarations-access.symbols b/tests/baselines/reference/letDeclarations-access.symbols index 078ad740d20..31a64fab3f8 100644 --- a/tests/baselines/reference/letDeclarations-access.symbols +++ b/tests/baselines/reference/letDeclarations-access.symbols @@ -1,87 +1,86 @@ === tests/cases/compiler/letDeclarations-access.ts === - let x = 0 ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) // No errors x = 1; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x += 2; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x -= 3; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x *= 4; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x /= 5; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x %= 6; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x <<= 7; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x >>= 8; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x >>>= 9; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x &= 10; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x |= 11; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x ^= 12; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x++; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x--; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) ++x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) --x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) var a = x + 1; ->a : Symbol(a, Decl(letDeclarations-access.ts, 23, 3)) ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>a : Symbol(a, Decl(letDeclarations-access.ts, 22, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) function f(v: number) { } ->f : Symbol(f, Decl(letDeclarations-access.ts, 23, 14)) ->v : Symbol(v, Decl(letDeclarations-access.ts, 25, 11)) +>f : Symbol(f, Decl(letDeclarations-access.ts, 22, 14)) +>v : Symbol(v, Decl(letDeclarations-access.ts, 24, 11)) f(x); ->f : Symbol(f, Decl(letDeclarations-access.ts, 23, 14)) ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>f : Symbol(f, Decl(letDeclarations-access.ts, 22, 14)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) if (x) { } ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) (x); ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) -x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) +x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x.toString(); >x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) >toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) diff --git a/tests/baselines/reference/letDeclarations-access.types b/tests/baselines/reference/letDeclarations-access.types index b2f984a4956..e36d7b7ad02 100644 --- a/tests/baselines/reference/letDeclarations-access.types +++ b/tests/baselines/reference/letDeclarations-access.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations-access.ts === - let x = 0 >x : number >0 : 0 diff --git a/tests/baselines/reference/letDeclarations-es5.js b/tests/baselines/reference/letDeclarations-es5.js index d8761ccbc64..a6df75c05ee 100644 --- a/tests/baselines/reference/letDeclarations-es5.js +++ b/tests/baselines/reference/letDeclarations-es5.js @@ -1,5 +1,4 @@ //// [letDeclarations-es5.ts] - let l1; let l2: number; let l3, l4, l5 :string, l6; diff --git a/tests/baselines/reference/letDeclarations-es5.symbols b/tests/baselines/reference/letDeclarations-es5.symbols index ac2daaaac89..512f384dc95 100644 --- a/tests/baselines/reference/letDeclarations-es5.symbols +++ b/tests/baselines/reference/letDeclarations-es5.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/letDeclarations-es5.ts === - let l1; ->l1 : Symbol(l1, Decl(letDeclarations-es5.ts, 1, 3)) +>l1 : Symbol(l1, Decl(letDeclarations-es5.ts, 0, 3)) let l2: number; ->l2 : Symbol(l2, Decl(letDeclarations-es5.ts, 2, 3)) +>l2 : Symbol(l2, Decl(letDeclarations-es5.ts, 1, 3)) let l3, l4, l5 :string, l6; ->l3 : Symbol(l3, Decl(letDeclarations-es5.ts, 3, 3)) ->l4 : Symbol(l4, Decl(letDeclarations-es5.ts, 3, 7)) ->l5 : Symbol(l5, Decl(letDeclarations-es5.ts, 3, 11)) ->l6 : Symbol(l6, Decl(letDeclarations-es5.ts, 3, 23)) +>l3 : Symbol(l3, Decl(letDeclarations-es5.ts, 2, 3)) +>l4 : Symbol(l4, Decl(letDeclarations-es5.ts, 2, 7)) +>l5 : Symbol(l5, Decl(letDeclarations-es5.ts, 2, 11)) +>l6 : Symbol(l6, Decl(letDeclarations-es5.ts, 2, 23)) let l7 = false; ->l7 : Symbol(l7, Decl(letDeclarations-es5.ts, 5, 3)) +>l7 : Symbol(l7, Decl(letDeclarations-es5.ts, 4, 3)) let l8: number = 23; ->l8 : Symbol(l8, Decl(letDeclarations-es5.ts, 6, 3)) +>l8 : Symbol(l8, Decl(letDeclarations-es5.ts, 5, 3)) let l9 = 0, l10 :string = "", l11 = null; ->l9 : Symbol(l9, Decl(letDeclarations-es5.ts, 7, 3)) ->l10 : Symbol(l10, Decl(letDeclarations-es5.ts, 7, 11)) ->l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 7, 29)) +>l9 : Symbol(l9, Decl(letDeclarations-es5.ts, 6, 3)) +>l10 : Symbol(l10, Decl(letDeclarations-es5.ts, 6, 11)) +>l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 6, 29)) for(let l11 in {}) { } ->l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 9, 7)) +>l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 8, 7)) for(let l12 = 0; l12 < 9; l12++) { } ->l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7)) +>l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 10, 7)) diff --git a/tests/baselines/reference/letDeclarations-es5.types b/tests/baselines/reference/letDeclarations-es5.types index 9756951e705..5d0f69576a9 100644 --- a/tests/baselines/reference/letDeclarations-es5.types +++ b/tests/baselines/reference/letDeclarations-es5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations-es5.ts === - let l1; >l1 : any diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt index d8230f29703..2541dd107c5 100644 --- a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt +++ b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt @@ -1,17 +1,15 @@ +tests/cases/compiler/letDeclarations-invalidContexts.ts(3,5): error TS1157: 'let' declarations can only be declared inside a block. tests/cases/compiler/letDeclarations-invalidContexts.ts(5,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(7,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(10,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(13,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(17,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/compiler/letDeclarations-invalidContexts.ts(21,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(24,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(27,12): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(30,29): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(8,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(11,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(15,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/letDeclarations-invalidContexts.ts(19,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(22,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(25,12): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(28,29): error TS1157: 'let' declarations can only be declared inside a block. ==== tests/cases/compiler/letDeclarations-invalidContexts.ts (9 errors) ==== - - // Errors, let must be defined inside a block if (true) let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.js b/tests/baselines/reference/letDeclarations-invalidContexts.js index 4c3be1faed8..ab06efa05fa 100644 --- a/tests/baselines/reference/letDeclarations-invalidContexts.js +++ b/tests/baselines/reference/letDeclarations-invalidContexts.js @@ -1,6 +1,4 @@ //// [letDeclarations-invalidContexts.ts] - - // Errors, let must be defined inside a block if (true) let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt index b3b620a4c9e..ced56226e2e 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt @@ -1,31 +1,30 @@ +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(6,5): error TS2451: Cannot redeclare block-scoped variable 'var2'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(7,7): error TS2451: Cannot redeclare block-scoped variable 'var2'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(9,7): error TS2451: Cannot redeclare block-scoped variable 'var3'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(10,5): error TS2451: Cannot redeclare block-scoped variable 'var3'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(5,5): error TS2451: Cannot redeclare block-scoped variable 'var2'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(6,7): error TS2451: Cannot redeclare block-scoped variable 'var2'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(8,7): error TS2451: Cannot redeclare block-scoped variable 'var3'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(9,5): error TS2451: Cannot redeclare block-scoped variable 'var3'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(11,7): error TS2451: Cannot redeclare block-scoped variable 'var4'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(12,7): error TS2451: Cannot redeclare block-scoped variable 'var4'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(13,7): error TS2451: Cannot redeclare block-scoped variable 'var4'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(14,5): error TS2300: Duplicate identifier 'var5'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(15,5): error TS2300: Duplicate identifier 'var5'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(16,5): error TS2300: Duplicate identifier 'var5'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(17,5): error TS2451: Cannot redeclare block-scoped variable 'var6'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(18,5): error TS2451: Cannot redeclare block-scoped variable 'var6'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(19,5): error TS2451: Cannot redeclare block-scoped variable 'var6'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(21,9): error TS2451: Cannot redeclare block-scoped variable 'var7'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(22,9): error TS2451: Cannot redeclare block-scoped variable 'var7'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'var7'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(25,13): error TS2451: Cannot redeclare block-scoped variable 'var8'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(26,15): error TS2451: Cannot redeclare block-scoped variable 'var8'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(24,13): error TS2451: Cannot redeclare block-scoped variable 'var8'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(25,15): error TS2451: Cannot redeclare block-scoped variable 'var8'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(31,13): error TS2451: Cannot redeclare block-scoped variable 'var9'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'var9'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(33,13): error TS2451: Cannot redeclare block-scoped variable 'var9'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(36,11): error TS2451: Cannot redeclare block-scoped variable 'var10'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(37,11): error TS2451: Cannot redeclare block-scoped variable 'var10'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(38,11): error TS2451: Cannot redeclare block-scoped variable 'var10'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(40,9): error TS2451: Cannot redeclare block-scoped variable 'var11'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(41,9): error TS2451: Cannot redeclare block-scoped variable 'var11'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(42,9): error TS2451: Cannot redeclare block-scoped variable 'var11'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(45,9): error TS2451: Cannot redeclare block-scoped variable 'var12'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(46,9): error TS2451: Cannot redeclare block-scoped variable 'var12'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(47,9): error TS2451: Cannot redeclare block-scoped variable 'var12'. ==== tests/cases/compiler/letDeclarations-scopes-duplicates.ts (24 errors) ==== - // Errors: redeclaration let var1 = 0; ~~~~ diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates.js b/tests/baselines/reference/letDeclarations-scopes-duplicates.js index c7d2ef9863a..4318af73c5b 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates.js @@ -1,5 +1,4 @@ //// [letDeclarations-scopes-duplicates.ts] - // Errors: redeclaration let var1 = 0; let var1 = 0; // error diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt index 72b8b5609b6..6b076197816 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - let var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates2.js b/tests/baselines/reference/letDeclarations-scopes-duplicates2.js index 9b35bd81c76..0647b4ac127 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates2.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates2.ts] //// //// [file1.ts] - let var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt index 6ed2fb66195..2ce3fd1c41a 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - let var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates3.js b/tests/baselines/reference/letDeclarations-scopes-duplicates3.js index e74caf37219..ece7c740462 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates3.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates3.ts] //// //// [file1.ts] - let var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt index ec87809b0cd..b276d6a3515 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - const var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates4.js b/tests/baselines/reference/letDeclarations-scopes-duplicates4.js index ac338e31c72..68d31e011d6 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates4.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates4.ts] //// //// [file1.ts] - const var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt index ce3a9da598a..09955c14bc0 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - const var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates5.js b/tests/baselines/reference/letDeclarations-scopes-duplicates5.js index 2424c91ab90..524a1f0e116 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates5.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates5.ts] //// //// [file1.ts] - const var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt index d09eda28075..1d39bcde276 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - var var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates6.js b/tests/baselines/reference/letDeclarations-scopes-duplicates6.js index 24edc0b7bde..ba4aeed7d8a 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates6.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates6.ts] //// //// [file1.ts] - var var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt index dad85f9f819..bead743dc4e 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - let var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates7.js b/tests/baselines/reference/letDeclarations-scopes-duplicates7.js index 4cbc359e2c2..e11a51d31d8 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates7.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates7.ts] //// //// [file1.ts] - let var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes.errors.txt b/tests/baselines/reference/letDeclarations-scopes.errors.txt index a44f6a90f7a..90896f1f895 100644 --- a/tests/baselines/reference/letDeclarations-scopes.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/letDeclarations-scopes.ts(29,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/letDeclarations-scopes.ts(27,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/letDeclarations-scopes.ts (1 errors) ==== - - // global let l = "string"; diff --git a/tests/baselines/reference/letDeclarations-scopes.js b/tests/baselines/reference/letDeclarations-scopes.js index 3fc5976b4b7..9d6d9acb3d9 100644 --- a/tests/baselines/reference/letDeclarations-scopes.js +++ b/tests/baselines/reference/letDeclarations-scopes.js @@ -1,6 +1,4 @@ //// [letDeclarations-scopes.ts] - - // global let l = "string"; diff --git a/tests/baselines/reference/letDeclarations-scopes2.errors.txt b/tests/baselines/reference/letDeclarations-scopes2.errors.txt index a786db1104b..8e0cf04aa14 100644 --- a/tests/baselines/reference/letDeclarations-scopes2.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/letDeclarations-scopes2.ts(9,5): error TS2304: Cannot find name 'local2'. -tests/cases/compiler/letDeclarations-scopes2.ts(21,5): error TS2304: Cannot find name 'local2'. -tests/cases/compiler/letDeclarations-scopes2.ts(24,1): error TS2304: Cannot find name 'local'. -tests/cases/compiler/letDeclarations-scopes2.ts(26,1): error TS2304: Cannot find name 'local2'. +tests/cases/compiler/letDeclarations-scopes2.ts(8,5): error TS2304: Cannot find name 'local2'. +tests/cases/compiler/letDeclarations-scopes2.ts(20,5): error TS2304: Cannot find name 'local2'. +tests/cases/compiler/letDeclarations-scopes2.ts(23,1): error TS2304: Cannot find name 'local'. +tests/cases/compiler/letDeclarations-scopes2.ts(25,1): error TS2304: Cannot find name 'local2'. ==== tests/cases/compiler/letDeclarations-scopes2.ts (4 errors) ==== - let global = 0; { diff --git a/tests/baselines/reference/letDeclarations-scopes2.js b/tests/baselines/reference/letDeclarations-scopes2.js index 98d0e791832..c21d7f4671f 100644 --- a/tests/baselines/reference/letDeclarations-scopes2.js +++ b/tests/baselines/reference/letDeclarations-scopes2.js @@ -1,5 +1,4 @@ //// [letDeclarations-scopes2.ts] - let global = 0; { diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt b/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt index 74c354f4ff2..69721a93b63 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(3,5): error TS2448: Block-scoped variable 'l1' used before its declaration. -tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(9,5): error TS2448: Block-scoped variable 'v1' used before its declaration. +tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(2,5): error TS2448: Block-scoped variable 'l1' used before its declaration. +tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(8,5): error TS2448: Block-scoped variable 'v1' used before its declaration. ==== tests/cases/compiler/letDeclarations-useBeforeDefinition.ts (2 errors) ==== - { l1; ~~ diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition.js b/tests/baselines/reference/letDeclarations-useBeforeDefinition.js index be1f9a127f4..52c37633b67 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition.js +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition.js @@ -1,5 +1,4 @@ //// [letDeclarations-useBeforeDefinition.ts] - { l1; let l1; diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt index 5b8633312d9..8820af5cc7c 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'l' used before its declaration. +tests/cases/compiler/file1.ts(1,1): error TS2448: Block-scoped variable 'l' used before its declaration. ==== tests/cases/compiler/file1.ts (1 errors) ==== - l; ~ !!! error TS2448: Block-scoped variable 'l' used before its declaration. diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js index 35560edd1c8..515ef338dda 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-useBeforeDefinition2.ts] //// //// [file1.ts] - l; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-validContexts.errors.txt b/tests/baselines/reference/letDeclarations-validContexts.errors.txt index dfd60c7ee53..9613472541c 100644 --- a/tests/baselines/reference/letDeclarations-validContexts.errors.txt +++ b/tests/baselines/reference/letDeclarations-validContexts.errors.txt @@ -1,10 +1,7 @@ -tests/cases/compiler/letDeclarations-validContexts.ts(21,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/letDeclarations-validContexts.ts(18,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/letDeclarations-validContexts.ts (1 errors) ==== - - - // Control flow statements with blocks if (true) { let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-validContexts.js b/tests/baselines/reference/letDeclarations-validContexts.js index 1859a0215bb..94d9bed1554 100644 --- a/tests/baselines/reference/letDeclarations-validContexts.js +++ b/tests/baselines/reference/letDeclarations-validContexts.js @@ -1,7 +1,4 @@ //// [letDeclarations-validContexts.ts] - - - // Control flow statements with blocks if (true) { let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations.js b/tests/baselines/reference/letDeclarations.js index 8acb82204e3..7ad1bf8f2b3 100644 --- a/tests/baselines/reference/letDeclarations.js +++ b/tests/baselines/reference/letDeclarations.js @@ -1,5 +1,4 @@ //// [letDeclarations.ts] - let l1; let l2: number; let l3, l4, l5 :string, l6; diff --git a/tests/baselines/reference/letDeclarations.symbols b/tests/baselines/reference/letDeclarations.symbols index dbbaac211ac..e4c7ed54748 100644 --- a/tests/baselines/reference/letDeclarations.symbols +++ b/tests/baselines/reference/letDeclarations.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/letDeclarations.ts === - let l1; ->l1 : Symbol(l1, Decl(letDeclarations.ts, 1, 3)) +>l1 : Symbol(l1, Decl(letDeclarations.ts, 0, 3)) let l2: number; ->l2 : Symbol(l2, Decl(letDeclarations.ts, 2, 3)) +>l2 : Symbol(l2, Decl(letDeclarations.ts, 1, 3)) let l3, l4, l5 :string, l6; ->l3 : Symbol(l3, Decl(letDeclarations.ts, 3, 3)) ->l4 : Symbol(l4, Decl(letDeclarations.ts, 3, 7)) ->l5 : Symbol(l5, Decl(letDeclarations.ts, 3, 11)) ->l6 : Symbol(l6, Decl(letDeclarations.ts, 3, 23)) +>l3 : Symbol(l3, Decl(letDeclarations.ts, 2, 3)) +>l4 : Symbol(l4, Decl(letDeclarations.ts, 2, 7)) +>l5 : Symbol(l5, Decl(letDeclarations.ts, 2, 11)) +>l6 : Symbol(l6, Decl(letDeclarations.ts, 2, 23)) let l7 = false; ->l7 : Symbol(l7, Decl(letDeclarations.ts, 5, 3)) +>l7 : Symbol(l7, Decl(letDeclarations.ts, 4, 3)) let l8: number = 23; ->l8 : Symbol(l8, Decl(letDeclarations.ts, 6, 3)) +>l8 : Symbol(l8, Decl(letDeclarations.ts, 5, 3)) let l9 = 0, l10 :string = "", l11 = null; ->l9 : Symbol(l9, Decl(letDeclarations.ts, 7, 3)) ->l10 : Symbol(l10, Decl(letDeclarations.ts, 7, 11)) ->l11 : Symbol(l11, Decl(letDeclarations.ts, 7, 29)) +>l9 : Symbol(l9, Decl(letDeclarations.ts, 6, 3)) +>l10 : Symbol(l10, Decl(letDeclarations.ts, 6, 11)) +>l11 : Symbol(l11, Decl(letDeclarations.ts, 6, 29)) for(let l11 in {}) { } ->l11 : Symbol(l11, Decl(letDeclarations.ts, 9, 7)) +>l11 : Symbol(l11, Decl(letDeclarations.ts, 8, 7)) for(let l12 = 0; l12 < 9; l12++) { } ->l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7)) +>l12 : Symbol(l12, Decl(letDeclarations.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations.ts, 10, 7)) diff --git a/tests/baselines/reference/letDeclarations.types b/tests/baselines/reference/letDeclarations.types index b1548f788ef..536d6ea3a7a 100644 --- a/tests/baselines/reference/letDeclarations.types +++ b/tests/baselines/reference/letDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations.ts === - let l1; >l1 : any diff --git a/tests/baselines/reference/letDeclarations2.js b/tests/baselines/reference/letDeclarations2.js index 8a6f039f2ca..c8b0216fce4 100644 --- a/tests/baselines/reference/letDeclarations2.js +++ b/tests/baselines/reference/letDeclarations2.js @@ -1,5 +1,4 @@ //// [letDeclarations2.ts] - module M { let l1 = "s"; export let l2 = 0; diff --git a/tests/baselines/reference/letDeclarations2.symbols b/tests/baselines/reference/letDeclarations2.symbols index 1f4bcb12420..9adb352a5c8 100644 --- a/tests/baselines/reference/letDeclarations2.symbols +++ b/tests/baselines/reference/letDeclarations2.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letDeclarations2.ts === - module M { >M : Symbol(M, Decl(letDeclarations2.ts, 0, 0)) let l1 = "s"; ->l1 : Symbol(l1, Decl(letDeclarations2.ts, 2, 7)) +>l1 : Symbol(l1, Decl(letDeclarations2.ts, 1, 7)) export let l2 = 0; ->l2 : Symbol(l2, Decl(letDeclarations2.ts, 3, 14)) +>l2 : Symbol(l2, Decl(letDeclarations2.ts, 2, 14)) } diff --git a/tests/baselines/reference/letDeclarations2.types b/tests/baselines/reference/letDeclarations2.types index 893514adb3f..6648957e3d7 100644 --- a/tests/baselines/reference/letDeclarations2.types +++ b/tests/baselines/reference/letDeclarations2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations2.ts === - module M { >M : typeof M diff --git a/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt b/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt index 8b694c35dbb..bcb42048cb9 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt +++ b/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInConstDeclarations_ES5.ts(3,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInConstDeclarations_ES5.ts(6,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES5.ts(2,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES5.ts(5,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInConstDeclarations_ES5.ts (2 errors) ==== - // All use of let in const declaration should be an error const x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInConstDeclarations_ES5.js b/tests/baselines/reference/letInConstDeclarations_ES5.js index f76d49765f0..b92ea8852a9 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES5.js +++ b/tests/baselines/reference/letInConstDeclarations_ES5.js @@ -1,5 +1,4 @@ //// [letInConstDeclarations_ES5.ts] - // All use of let in const declaration should be an error const x = 50, let = 5; diff --git a/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt b/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt index d29f78be014..c14bb5de7e6 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt +++ b/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInConstDeclarations_ES6.ts(3,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInConstDeclarations_ES6.ts(6,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES6.ts(2,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES6.ts(5,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInConstDeclarations_ES6.ts (2 errors) ==== - // All use of let in const declaration should be an error const x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInConstDeclarations_ES6.js b/tests/baselines/reference/letInConstDeclarations_ES6.js index f209ef1dede..3dc25e88ac0 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES6.js +++ b/tests/baselines/reference/letInConstDeclarations_ES6.js @@ -1,5 +1,4 @@ //// [letInConstDeclarations_ES6.ts] - // All use of let in const declaration should be an error const x = 50, let = 5; diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt index e335a9652f4..dfc98387e09 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(3,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(5,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(7,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(9,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(12,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(14,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(16,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(18,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(2,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(4,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(6,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(8,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(11,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(13,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(15,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(17,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts (8 errors) ==== - // Should be an error for (let let of [1,2,3]) {} ~~~ diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js index 4c467176492..1ce535b095b 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js @@ -1,5 +1,4 @@ //// [letInLetConstDeclOfForOfAndForIn_ES5.ts] - // Should be an error for (let let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt index 1a5af892b74..c7980686a07 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(3,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(5,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(7,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(9,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(12,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(14,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(16,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(18,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(2,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(4,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(6,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(8,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(11,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(13,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(15,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(17,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts (8 errors) ==== - // Should be an error for (let let of [1,2,3]) {} ~~~ diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js index 583dc936871..fdcce5aca06 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js @@ -1,5 +1,4 @@ //// [letInLetConstDeclOfForOfAndForIn_ES6.ts] - // Should be an error for (let let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt b/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt index 73f824dd7de..f359c60df9d 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt +++ b/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInLetDeclarations_ES5.ts(3,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetDeclarations_ES5.ts(6,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES5.ts(2,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES5.ts(5,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetDeclarations_ES5.ts (2 errors) ==== - // All use of let in const declaration should be an error let x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInLetDeclarations_ES5.js b/tests/baselines/reference/letInLetDeclarations_ES5.js index 0b7f02150a4..03b73e95e19 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES5.js +++ b/tests/baselines/reference/letInLetDeclarations_ES5.js @@ -1,5 +1,4 @@ //// [letInLetDeclarations_ES5.ts] - // All use of let in const declaration should be an error let x = 50, let = 5; diff --git a/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt b/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt index 0fe1aa882e9..fa2372ea009 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt +++ b/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInLetDeclarations_ES6.ts(3,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetDeclarations_ES6.ts(6,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES6.ts(2,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES6.ts(5,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetDeclarations_ES6.ts (2 errors) ==== - // All use of let in const declaration should be an error let x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInLetDeclarations_ES6.js b/tests/baselines/reference/letInLetDeclarations_ES6.js index 7c4385cd4d9..35bbef9f2d3 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES6.js +++ b/tests/baselines/reference/letInLetDeclarations_ES6.js @@ -1,5 +1,4 @@ //// [letInLetDeclarations_ES6.ts] - // All use of let in const declaration should be an error let x = 50, let = 5; diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES5.js b/tests/baselines/reference/letInVarDeclOfForIn_ES5.js index 2cef7610199..36de180f10d 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES5.js +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES5.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForIn_ES5.ts] - // should not be an error for (var let in [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols b/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols index cbfd0f58086..1870128b084 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES5.ts === - // should not be an error for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 2, 8), Decl(letInVarDeclOfForIn_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 1, 8), Decl(letInVarDeclOfForIn_ES5.ts, 4, 9)) { for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 2, 8), Decl(letInVarDeclOfForIn_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 1, 8), Decl(letInVarDeclOfForIn_ES5.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES5.types b/tests/baselines/reference/letInVarDeclOfForIn_ES5.types index d3751f58959..ddb78832d5b 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES5.types +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES5.ts === - // should not be an error for (var let in [1,2,3]) {} >let : string diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES6.js b/tests/baselines/reference/letInVarDeclOfForIn_ES6.js index 1cf6850f588..140887e06c9 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES6.js +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES6.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForIn_ES6.ts] - // should not be an error for (var let in [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols b/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols index 3b3e68e3040..d4757a6a293 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES6.ts === - // should not be an error for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 2, 8), Decl(letInVarDeclOfForIn_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 1, 8), Decl(letInVarDeclOfForIn_ES6.ts, 4, 9)) { for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 2, 8), Decl(letInVarDeclOfForIn_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 1, 8), Decl(letInVarDeclOfForIn_ES6.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES6.types b/tests/baselines/reference/letInVarDeclOfForIn_ES6.types index 1d672c12ea6..1db8d6b5bab 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES6.types +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES6.ts === - // should not be an error for (var let in [1,2,3]) {} >let : string diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES5.js b/tests/baselines/reference/letInVarDeclOfForOf_ES5.js index cdc374fbea0..90c203b47ad 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES5.js +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES5.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForOf_ES5.ts] - // should not be an error for (var let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols b/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols index f5411cfca2d..ae9433da1e7 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES5.ts === - // should not be an error for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 2, 8), Decl(letInVarDeclOfForOf_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 1, 8), Decl(letInVarDeclOfForOf_ES5.ts, 4, 9)) { for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 2, 8), Decl(letInVarDeclOfForOf_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 1, 8), Decl(letInVarDeclOfForOf_ES5.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES5.types b/tests/baselines/reference/letInVarDeclOfForOf_ES5.types index 6b1648dcaf3..642de2e8337 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES5.types +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES5.ts === - // should not be an error for (var let of [1,2,3]) {} >let : number diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES6.js b/tests/baselines/reference/letInVarDeclOfForOf_ES6.js index fca365c4b0d..867e2cbab61 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES6.js +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES6.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForOf_ES6.ts] - // should not be an error for (var let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols b/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols index d4c14eff0b0..6b632793ef7 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES6.ts === - // should not be an error for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 2, 8), Decl(letInVarDeclOfForOf_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 1, 8), Decl(letInVarDeclOfForOf_ES6.ts, 4, 9)) { for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 2, 8), Decl(letInVarDeclOfForOf_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 1, 8), Decl(letInVarDeclOfForOf_ES6.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES6.types b/tests/baselines/reference/letInVarDeclOfForOf_ES6.types index 3231dbc0b2c..8e114def98e 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES6.types +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES6.ts === - // should not be an error for (var let of [1,2,3]) {} >let : number diff --git a/tests/baselines/reference/library-reference-1.js b/tests/baselines/reference/library-reference-1.js index e709db72dea..2533b8ae79e 100644 --- a/tests/baselines/reference/library-reference-1.js +++ b/tests/baselines/reference/library-reference-1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-1.ts] //// //// [index.d.ts] - // We can find typings in the ./types folder declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-1.symbols b/tests/baselines/reference/library-reference-1.symbols index 14a6b115009..14a539f7848 100644 --- a/tests/baselines/reference/library-reference-1.symbols +++ b/tests/baselines/reference/library-reference-1.symbols @@ -1,16 +1,15 @@ === /src/consumer.ts === /// $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 3, 16)) ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 2, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) === /src/types/jquery/index.d.ts === - // We can find typings in the ./types folder declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) diff --git a/tests/baselines/reference/library-reference-1.types b/tests/baselines/reference/library-reference-1.types index c247e94617e..851520a1462 100644 --- a/tests/baselines/reference/library-reference-1.types +++ b/tests/baselines/reference/library-reference-1.types @@ -7,7 +7,6 @@ $.foo(); >foo : () => void === /src/types/jquery/index.d.ts === - // We can find typings in the ./types folder declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-10.js b/tests/baselines/reference/library-reference-10.js index a6dbdfce610..f682c9ccc2f 100644 --- a/tests/baselines/reference/library-reference-10.js +++ b/tests/baselines/reference/library-reference-10.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-10.ts] //// //// [package.json] - // package.json in a primary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-11.js b/tests/baselines/reference/library-reference-11.js index 773fe5a890a..e070f82805d 100644 --- a/tests/baselines/reference/library-reference-11.js +++ b/tests/baselines/reference/library-reference-11.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-11.ts] //// //// [package.json] - // package.json in a secondary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-12.js b/tests/baselines/reference/library-reference-12.js index 42d0f650b50..77f5da776ce 100644 --- a/tests/baselines/reference/library-reference-12.js +++ b/tests/baselines/reference/library-reference-12.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-12.ts] //// //// [package.json] - // package.json in a secondary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-14.js b/tests/baselines/reference/library-reference-14.js index 0fb5ff04fb9..03ac3fab825 100644 --- a/tests/baselines/reference/library-reference-14.js +++ b/tests/baselines/reference/library-reference-14.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-14.ts] //// //// [index.d.ts] - declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-14.symbols b/tests/baselines/reference/library-reference-14.symbols index 162afc50ca7..04d50373caa 100644 --- a/tests/baselines/reference/library-reference-14.symbols +++ b/tests/baselines/reference/library-reference-14.symbols @@ -1,13 +1,12 @@ === /a/b/consumer.ts === $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 1, 16)) ->$ : Symbol($, Decl(index.d.ts, 1, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 1, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 0, 16)) +>$ : Symbol($, Decl(index.d.ts, 0, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 0, 16)) === /a/types/jquery/index.d.ts === - declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 1, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 1, 16)) +>$ : Symbol($, Decl(index.d.ts, 0, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 0, 16)) diff --git a/tests/baselines/reference/library-reference-14.types b/tests/baselines/reference/library-reference-14.types index f4196e10744..b00d778c5b2 100644 --- a/tests/baselines/reference/library-reference-14.types +++ b/tests/baselines/reference/library-reference-14.types @@ -6,7 +6,6 @@ $.foo(); >foo : () => void === /a/types/jquery/index.d.ts === - declare var $: { foo(): void }; >$ : { foo(): void; } >foo : () => void diff --git a/tests/baselines/reference/library-reference-15.errors.txt b/tests/baselines/reference/library-reference-15.errors.txt index 9586ba8bc72..f4cee66d1a1 100644 --- a/tests/baselines/reference/library-reference-15.errors.txt +++ b/tests/baselines/reference/library-reference-15.errors.txt @@ -7,7 +7,6 @@ ~~ !!! error TS2304: Cannot find name '$2'. ==== /a/types/jquery/index.d.ts (0 errors) ==== - declare var $: { foo(): void }; ==== /a/types/jquery2/index.d.ts (0 errors) ==== diff --git a/tests/baselines/reference/library-reference-15.js b/tests/baselines/reference/library-reference-15.js index c1caa0c45e7..bdbf0c9a1c2 100644 --- a/tests/baselines/reference/library-reference-15.js +++ b/tests/baselines/reference/library-reference-15.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-15.ts] //// //// [index.d.ts] - declare var $: { foo(): void }; //// [index.d.ts] diff --git a/tests/baselines/reference/library-reference-2.js b/tests/baselines/reference/library-reference-2.js index 20729db6c60..311b928a5bd 100644 --- a/tests/baselines/reference/library-reference-2.js +++ b/tests/baselines/reference/library-reference-2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-2.ts] //// //// [package.json] - // package.json in a primary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-3.js b/tests/baselines/reference/library-reference-3.js index 6f9ad2d43d2..687a3c8f8ac 100644 --- a/tests/baselines/reference/library-reference-3.js +++ b/tests/baselines/reference/library-reference-3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-3.ts] //// //// [index.d.ts] - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-3.symbols b/tests/baselines/reference/library-reference-3.symbols index a1785fd77c9..c49d48f315e 100644 --- a/tests/baselines/reference/library-reference-3.symbols +++ b/tests/baselines/reference/library-reference-3.symbols @@ -1,15 +1,14 @@ === /src/consumer.ts === /// $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 3, 16)) ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 2, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) diff --git a/tests/baselines/reference/library-reference-3.types b/tests/baselines/reference/library-reference-3.types index ed7da59525f..10fd29c4d5f 100644 --- a/tests/baselines/reference/library-reference-3.types +++ b/tests/baselines/reference/library-reference-3.types @@ -7,7 +7,6 @@ $.foo(); >foo : () => void === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-4.js b/tests/baselines/reference/library-reference-4.js index 39e4b1d73a5..e4f4bf4996a 100644 --- a/tests/baselines/reference/library-reference-4.js +++ b/tests/baselines/reference/library-reference-4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-4.ts] //// //// [index.d.ts] - // Secondary references may be duplicated if they agree in content /// diff --git a/tests/baselines/reference/library-reference-4.symbols b/tests/baselines/reference/library-reference-4.symbols index f7c082a946d..37a0e267d00 100644 --- a/tests/baselines/reference/library-reference-4.symbols +++ b/tests/baselines/reference/library-reference-4.symbols @@ -3,12 +3,11 @@ No type information for this code./// No type information for this code. No type information for this code.=== /node_modules/foo/index.d.ts === - // Secondary references may be duplicated if they agree in content /// declare var foo: any; ->foo : Symbol(foo, Decl(index.d.ts, 4, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 3, 11)) === /node_modules/foo/node_modules/alpha/index.d.ts === declare var alpha: any; diff --git a/tests/baselines/reference/library-reference-4.types b/tests/baselines/reference/library-reference-4.types index a0a7d370b4c..329ad50995f 100644 --- a/tests/baselines/reference/library-reference-4.types +++ b/tests/baselines/reference/library-reference-4.types @@ -3,7 +3,6 @@ No type information for this code./// No type information for this code. No type information for this code.=== /node_modules/foo/index.d.ts === - // Secondary references may be duplicated if they agree in content /// diff --git a/tests/baselines/reference/library-reference-5.errors.txt b/tests/baselines/reference/library-reference-5.errors.txt index c23b49c61de..2130b1ce037 100644 --- a/tests/baselines/reference/library-reference-5.errors.txt +++ b/tests/baselines/reference/library-reference-5.errors.txt @@ -6,7 +6,6 @@ /// ==== /node_modules/foo/index.d.ts (0 errors) ==== - // Secondary references may not be duplicated if they disagree in content /// diff --git a/tests/baselines/reference/library-reference-5.js b/tests/baselines/reference/library-reference-5.js index 40d2131920e..0f39b31300f 100644 --- a/tests/baselines/reference/library-reference-5.js +++ b/tests/baselines/reference/library-reference-5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-5.ts] //// //// [index.d.ts] - // Secondary references may not be duplicated if they disagree in content /// diff --git a/tests/baselines/reference/library-reference-6.js b/tests/baselines/reference/library-reference-6.js index d78a3a131a1..af364b31c4e 100644 --- a/tests/baselines/reference/library-reference-6.js +++ b/tests/baselines/reference/library-reference-6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-6.ts] //// //// [index.d.ts] - // The primary lookup folder is relative to tsconfig.json, if present declare var alpha: { a: string }; diff --git a/tests/baselines/reference/library-reference-6.symbols b/tests/baselines/reference/library-reference-6.symbols index 595d43df3fa..086795e85d4 100644 --- a/tests/baselines/reference/library-reference-6.symbols +++ b/tests/baselines/reference/library-reference-6.symbols @@ -2,15 +2,14 @@ /// var x: string = alpha.a; >x : Symbol(x, Decl(foo.ts, 1, 3)) ->alpha.a : Symbol(a, Decl(index.d.ts, 3, 20)) ->alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) ->a : Symbol(a, Decl(index.d.ts, 3, 20)) +>alpha.a : Symbol(a, Decl(index.d.ts, 2, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 2, 11)) +>a : Symbol(a, Decl(index.d.ts, 2, 20)) === /node_modules/@types/alpha/index.d.ts === - // The primary lookup folder is relative to tsconfig.json, if present declare var alpha: { a: string }; ->alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) ->a : Symbol(a, Decl(index.d.ts, 3, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 2, 11)) +>a : Symbol(a, Decl(index.d.ts, 2, 20)) diff --git a/tests/baselines/reference/library-reference-6.types b/tests/baselines/reference/library-reference-6.types index e2762c0943a..0dd804f8319 100644 --- a/tests/baselines/reference/library-reference-6.types +++ b/tests/baselines/reference/library-reference-6.types @@ -7,7 +7,6 @@ var x: string = alpha.a; >a : string === /node_modules/@types/alpha/index.d.ts === - // The primary lookup folder is relative to tsconfig.json, if present declare var alpha: { a: string }; diff --git a/tests/baselines/reference/library-reference-7.js b/tests/baselines/reference/library-reference-7.js index f1ef6ca4eab..dddd8fcc8cc 100644 --- a/tests/baselines/reference/library-reference-7.js +++ b/tests/baselines/reference/library-reference-7.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-7.ts] //// //// [index.d.ts] - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-7.symbols b/tests/baselines/reference/library-reference-7.symbols index a1785fd77c9..c49d48f315e 100644 --- a/tests/baselines/reference/library-reference-7.symbols +++ b/tests/baselines/reference/library-reference-7.symbols @@ -1,15 +1,14 @@ === /src/consumer.ts === /// $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 3, 16)) ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 2, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) diff --git a/tests/baselines/reference/library-reference-7.types b/tests/baselines/reference/library-reference-7.types index ed7da59525f..10fd29c4d5f 100644 --- a/tests/baselines/reference/library-reference-7.types +++ b/tests/baselines/reference/library-reference-7.types @@ -7,7 +7,6 @@ $.foo(); >foo : () => void === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-8.js b/tests/baselines/reference/library-reference-8.js index a48b226cb62..02a7c3da83c 100644 --- a/tests/baselines/reference/library-reference-8.js +++ b/tests/baselines/reference/library-reference-8.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-8.ts] //// //// [index.d.ts] - // Don't crash in circular library reference situations /// diff --git a/tests/baselines/reference/library-reference-8.symbols b/tests/baselines/reference/library-reference-8.symbols index a6a24689f3f..221f6e57c60 100644 --- a/tests/baselines/reference/library-reference-8.symbols +++ b/tests/baselines/reference/library-reference-8.symbols @@ -3,22 +3,21 @@ /// var x: string = alpha.a + beta.b; >x : Symbol(x, Decl(foo.ts, 2, 3)) ->alpha.a : Symbol(a, Decl(index.d.ts, 4, 20)) ->alpha : Symbol(alpha, Decl(index.d.ts, 4, 11)) ->a : Symbol(a, Decl(index.d.ts, 4, 20)) +>alpha.a : Symbol(a, Decl(index.d.ts, 3, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) +>a : Symbol(a, Decl(index.d.ts, 3, 20)) >beta.b : Symbol(b, Decl(index.d.ts, 1, 19)) >beta : Symbol(beta, Decl(index.d.ts, 1, 11)) >b : Symbol(b, Decl(index.d.ts, 1, 19)) === /test/types/alpha/index.d.ts === - // Don't crash in circular library reference situations /// declare var alpha: { a: string }; ->alpha : Symbol(alpha, Decl(index.d.ts, 4, 11)) ->a : Symbol(a, Decl(index.d.ts, 4, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) +>a : Symbol(a, Decl(index.d.ts, 3, 20)) === /test/types/beta/index.d.ts === /// diff --git a/tests/baselines/reference/library-reference-8.types b/tests/baselines/reference/library-reference-8.types index d8a2b6e9638..34c5186cca8 100644 --- a/tests/baselines/reference/library-reference-8.types +++ b/tests/baselines/reference/library-reference-8.types @@ -13,7 +13,6 @@ var x: string = alpha.a + beta.b; === /test/types/alpha/index.d.ts === - // Don't crash in circular library reference situations /// diff --git a/tests/baselines/reference/literalTypes1.js b/tests/baselines/reference/literalTypes1.js index cf2923e250a..2e8c179af87 100644 --- a/tests/baselines/reference/literalTypes1.js +++ b/tests/baselines/reference/literalTypes1.js @@ -1,5 +1,4 @@ //// [literalTypes1.ts] - let zero: 0 = 0; let one: 1 = 1; let two: 2 = 2; diff --git a/tests/baselines/reference/literalTypes1.symbols b/tests/baselines/reference/literalTypes1.symbols index ea44ab51acc..435cf4caf5f 100644 --- a/tests/baselines/reference/literalTypes1.symbols +++ b/tests/baselines/reference/literalTypes1.symbols @@ -1,170 +1,169 @@ === tests/cases/conformance/types/literal/literalTypes1.ts === - let zero: 0 = 0; ->zero : Symbol(zero, Decl(literalTypes1.ts, 1, 3)) +>zero : Symbol(zero, Decl(literalTypes1.ts, 0, 3)) let one: 1 = 1; ->one : Symbol(one, Decl(literalTypes1.ts, 2, 3)) +>one : Symbol(one, Decl(literalTypes1.ts, 1, 3)) let two: 2 = 2; ->two : Symbol(two, Decl(literalTypes1.ts, 3, 3)) +>two : Symbol(two, Decl(literalTypes1.ts, 2, 3)) let oneOrTwo: 1 | 2 = <1 | 2>1; ->oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 4, 3)) +>oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 3, 3)) function f1(x: 0 | 1 | 2) { ->f1 : Symbol(f1, Decl(literalTypes1.ts, 4, 31)) ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>f1 : Symbol(f1, Decl(literalTypes1.ts, 3, 31)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) case zero: ->zero : Symbol(zero, Decl(literalTypes1.ts, 1, 3)) +>zero : Symbol(zero, Decl(literalTypes1.ts, 0, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) break; case one: ->one : Symbol(one, Decl(literalTypes1.ts, 2, 3)) +>one : Symbol(one, Decl(literalTypes1.ts, 1, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) break; case two: ->two : Symbol(two, Decl(literalTypes1.ts, 3, 3)) +>two : Symbol(two, Decl(literalTypes1.ts, 2, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) } } function f2(x: 0 | 1 | 2) { ->f2 : Symbol(f2, Decl(literalTypes1.ts, 20, 1)) ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>f2 : Symbol(f2, Decl(literalTypes1.ts, 19, 1)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) case zero: ->zero : Symbol(zero, Decl(literalTypes1.ts, 1, 3)) +>zero : Symbol(zero, Decl(literalTypes1.ts, 0, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) break; case oneOrTwo: ->oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 4, 3)) +>oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 3, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) } } type Falsy = false | 0 | "" | null | undefined; ->Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 33, 1)) +>Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 32, 1)) function f3(x: Falsy) { ->f3 : Symbol(f3, Decl(literalTypes1.ts, 35, 47)) ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) ->Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 33, 1)) +>f3 : Symbol(f3, Decl(literalTypes1.ts, 34, 47)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) +>Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 32, 1)) if (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) } else { x; ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) } } function f4(x: 0 | 1 | true | string) { ->f4 : Symbol(f4, Decl(literalTypes1.ts, 44, 1)) ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>f4 : Symbol(f4, Decl(literalTypes1.ts, 43, 1)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) case 0: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case 1: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case "abc": case "def": x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case null: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case undefined: >undefined : Symbol(undefined) x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) } } function f5(x: string | number | boolean) { ->f5 : Symbol(f5, Decl(literalTypes1.ts, 67, 1)) ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>f5 : Symbol(f5, Decl(literalTypes1.ts, 66, 1)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) case "abc": x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; case 0: case 1: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; case true: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; case "hello": case 123: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) } } diff --git a/tests/baselines/reference/literalTypes1.types b/tests/baselines/reference/literalTypes1.types index 1baaad3ff88..ed2df4ca14c 100644 --- a/tests/baselines/reference/literalTypes1.types +++ b/tests/baselines/reference/literalTypes1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/literalTypes1.ts === - let zero: 0 = 0; >zero : 0 >0 : 0 diff --git a/tests/baselines/reference/literalTypes3.js b/tests/baselines/reference/literalTypes3.js index 1989bb1d5a1..46b6c6246e4 100644 --- a/tests/baselines/reference/literalTypes3.js +++ b/tests/baselines/reference/literalTypes3.js @@ -1,5 +1,4 @@ //// [literalTypes3.ts] - function f1(s: string) { if (s === "foo") { s; // "foo" diff --git a/tests/baselines/reference/literalTypes3.symbols b/tests/baselines/reference/literalTypes3.symbols index 6cc7ab007e6..85838498df1 100644 --- a/tests/baselines/reference/literalTypes3.symbols +++ b/tests/baselines/reference/literalTypes3.symbols @@ -1,137 +1,136 @@ === tests/cases/conformance/types/literal/literalTypes3.ts === - function f1(s: string) { >f1 : Symbol(f1, Decl(literalTypes3.ts, 0, 0)) ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) if (s === "foo") { ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) s; // "foo" ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) } if (s === "foo" || s === "bar") { ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) s; // "foo" | "bar" ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) } } function f2(s: string) { ->f2 : Symbol(f2, Decl(literalTypes3.ts, 8, 1)) ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>f2 : Symbol(f2, Decl(literalTypes3.ts, 7, 1)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) switch (s) { ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) case "foo": case "bar": s; // "foo" | "bar" ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) case "baz": s; // "foo" | "bar" | "baz" ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) break; default: s; // string ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) } } function f3(s: string) { ->f3 : Symbol(f3, Decl(literalTypes3.ts, 21, 1)) ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) +>f3 : Symbol(f3, Decl(literalTypes3.ts, 20, 1)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) return s === "foo" || s === "bar" ? s : undefined; // "foo" | "bar" | undefined ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) >undefined : Symbol(undefined) } function f4(x: number) { ->f4 : Symbol(f4, Decl(literalTypes3.ts, 25, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) +>f4 : Symbol(f4, Decl(literalTypes3.ts, 24, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) if (x === 1 || x === 2) { ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) return x; // 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) } throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f5(x: number, y: 1 | 2) { ->f5 : Symbol(f5, Decl(literalTypes3.ts, 32, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 34, 22)) +>f5 : Symbol(f5, Decl(literalTypes3.ts, 31, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 33, 22)) if (x === 0 || x === y) { ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 34, 22)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 33, 22)) x; // 0 | 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) } } function f6(x: number, y: 1 | 2) { ->f6 : Symbol(f6, Decl(literalTypes3.ts, 38, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 40, 22)) +>f6 : Symbol(f6, Decl(literalTypes3.ts, 37, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 39, 22)) if (y === x || 0 === x) { ->y : Symbol(y, Decl(literalTypes3.ts, 40, 22)) ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 39, 22)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) x; // 0 | 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) } } function f7(x: number | "foo" | "bar", y: 1 | 2 | string) { ->f7 : Symbol(f7, Decl(literalTypes3.ts, 44, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 46, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 46, 38)) +>f7 : Symbol(f7, Decl(literalTypes3.ts, 43, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 45, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 45, 38)) if (x === y) { ->x : Symbol(x, Decl(literalTypes3.ts, 46, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 46, 38)) +>x : Symbol(x, Decl(literalTypes3.ts, 45, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 45, 38)) x; // "foo" | "bar" | 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 45, 12)) } } function f8(x: number | "foo" | "bar") { ->f8 : Symbol(f8, Decl(literalTypes3.ts, 50, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>f8 : Symbol(f8, Decl(literalTypes3.ts, 49, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) case 1: case 2: x; // 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) break; case "foo": x; // "foo" ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) break; default: x; // number | "bar" ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) } } diff --git a/tests/baselines/reference/literalTypes3.types b/tests/baselines/reference/literalTypes3.types index 6161bc4b72a..059e2777e54 100644 --- a/tests/baselines/reference/literalTypes3.types +++ b/tests/baselines/reference/literalTypes3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/literalTypes3.ts === - function f1(s: string) { >f1 : (s: string) => void >s : string diff --git a/tests/baselines/reference/literals.errors.txt b/tests/baselines/reference/literals.errors.txt index ae058e0b530..426e832c622 100644 --- a/tests/baselines/reference/literals.errors.txt +++ b/tests/baselines/reference/literals.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/expressions/literals/literals.ts(9,10): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/literals/literals.ts(9,17): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/literals/literals.ts(10,9): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/literals/literals.ts(10,21): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/literals/literals.ts(20,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'. -tests/cases/conformance/expressions/literals/literals.ts(25,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. +tests/cases/conformance/expressions/literals/literals.ts(8,10): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/literals/literals.ts(8,17): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/literals/literals.ts(9,9): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/literals/literals.ts(9,21): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/literals/literals.ts(19,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'. +tests/cases/conformance/expressions/literals/literals.ts(24,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. ==== tests/cases/conformance/expressions/literals/literals.ts (6 errors) ==== - //typeof null is Null //typeof true is Boolean //typeof false is Boolean diff --git a/tests/baselines/reference/literals.js b/tests/baselines/reference/literals.js index b92e11c13ce..9f8d8f56be9 100644 --- a/tests/baselines/reference/literals.js +++ b/tests/baselines/reference/literals.js @@ -1,5 +1,4 @@ //// [literals.ts] - //typeof null is Null //typeof true is Boolean //typeof false is Boolean diff --git a/tests/baselines/reference/literalsInComputedProperties1.errors.txt b/tests/baselines/reference/literalsInComputedProperties1.errors.txt index e9972229f79..0a0412721db 100644 --- a/tests/baselines/reference/literalsInComputedProperties1.errors.txt +++ b/tests/baselines/reference/literalsInComputedProperties1.errors.txt @@ -1,11 +1,10 @@ +tests/cases/compiler/literalsInComputedProperties1.ts(39,5): error TS2452: An enum member cannot have a numeric name. tests/cases/compiler/literalsInComputedProperties1.ts(40,5): error TS2452: An enum member cannot have a numeric name. tests/cases/compiler/literalsInComputedProperties1.ts(41,5): error TS2452: An enum member cannot have a numeric name. tests/cases/compiler/literalsInComputedProperties1.ts(42,5): error TS2452: An enum member cannot have a numeric name. -tests/cases/compiler/literalsInComputedProperties1.ts(43,5): error TS2452: An enum member cannot have a numeric name. ==== tests/cases/compiler/literalsInComputedProperties1.ts (4 errors) ==== - let x = { 1:1, [2]:1, diff --git a/tests/baselines/reference/literalsInComputedProperties1.js b/tests/baselines/reference/literalsInComputedProperties1.js index 77eb70c2396..dd94709d2cf 100644 --- a/tests/baselines/reference/literalsInComputedProperties1.js +++ b/tests/baselines/reference/literalsInComputedProperties1.js @@ -1,5 +1,4 @@ //// [literalsInComputedProperties1.ts] - let x = { 1:1, [2]:1, diff --git a/tests/baselines/reference/localClassesInLoop_ES6.js b/tests/baselines/reference/localClassesInLoop_ES6.js index b9e7dccff1f..61c12944357 100644 --- a/tests/baselines/reference/localClassesInLoop_ES6.js +++ b/tests/baselines/reference/localClassesInLoop_ES6.js @@ -1,5 +1,4 @@ //// [localClassesInLoop_ES6.ts] - declare function use(a: any); "use strict" diff --git a/tests/baselines/reference/localClassesInLoop_ES6.symbols b/tests/baselines/reference/localClassesInLoop_ES6.symbols index f70373a4d73..582eca51f04 100644 --- a/tests/baselines/reference/localClassesInLoop_ES6.symbols +++ b/tests/baselines/reference/localClassesInLoop_ES6.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/localClassesInLoop_ES6.ts === - declare function use(a: any); >use : Symbol(use, Decl(localClassesInLoop_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(localClassesInLoop_ES6.ts, 1, 21)) +>a : Symbol(a, Decl(localClassesInLoop_ES6.ts, 0, 21)) "use strict" var data = []; ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) for (let x = 0; x < 2; ++x) { ->x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 5, 8)) ->x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 5, 8)) ->x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 5, 8)) +>x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 4, 8)) +>x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 4, 8)) +>x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 4, 8)) class C { } ->C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 5, 29)) +>C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 4, 29)) data.push(() => C); >data.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 5, 29)) +>C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 4, 29)) } use(data[0]() === data[1]()); >use : Symbol(use, Decl(localClassesInLoop_ES6.ts, 0, 0)) ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) diff --git a/tests/baselines/reference/localClassesInLoop_ES6.types b/tests/baselines/reference/localClassesInLoop_ES6.types index 9d487f6c600..971a127da40 100644 --- a/tests/baselines/reference/localClassesInLoop_ES6.types +++ b/tests/baselines/reference/localClassesInLoop_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/localClassesInLoop_ES6.ts === - declare function use(a: any); >use : (a: any) => any >a : any diff --git a/tests/baselines/reference/localRequireFunction.js b/tests/baselines/reference/localRequireFunction.js index 1ae20821a07..8f8fe2d40d8 100644 --- a/tests/baselines/reference/localRequireFunction.js +++ b/tests/baselines/reference/localRequireFunction.js @@ -1,5 +1,4 @@ //// [app.js] - function require(a) { return a; } diff --git a/tests/baselines/reference/localRequireFunction.symbols b/tests/baselines/reference/localRequireFunction.symbols index b977328f0ef..d8fbf23276a 100644 --- a/tests/baselines/reference/localRequireFunction.symbols +++ b/tests/baselines/reference/localRequireFunction.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/app.js === - function require(a) { >require : Symbol(require, Decl(app.js, 0, 0)) ->a : Symbol(a, Decl(app.js, 1, 17)) +>a : Symbol(a, Decl(app.js, 0, 17)) return a; ->a : Symbol(a, Decl(app.js, 1, 17)) +>a : Symbol(a, Decl(app.js, 0, 17)) } const fs = require("fs"); ->fs : Symbol(fs, Decl(app.js, 5, 5)) +>fs : Symbol(fs, Decl(app.js, 4, 5)) >require : Symbol(require, Decl(app.js, 0, 0)) const text = fs.readFileSync("/a/b/c"); ->text : Symbol(text, Decl(app.js, 6, 5)) ->fs : Symbol(fs, Decl(app.js, 5, 5)) +>text : Symbol(text, Decl(app.js, 5, 5)) +>fs : Symbol(fs, Decl(app.js, 4, 5)) diff --git a/tests/baselines/reference/localRequireFunction.types b/tests/baselines/reference/localRequireFunction.types index 4b5c7578cd9..21f9c81bd29 100644 --- a/tests/baselines/reference/localRequireFunction.types +++ b/tests/baselines/reference/localRequireFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/app.js === - function require(a) { >require : (a: any) => any >a : any diff --git a/tests/baselines/reference/localTypes1.js b/tests/baselines/reference/localTypes1.js index d356bd58e20..ab12be6d9fc 100644 --- a/tests/baselines/reference/localTypes1.js +++ b/tests/baselines/reference/localTypes1.js @@ -1,5 +1,4 @@ //// [localTypes1.ts] - function f1() { enum E { A, B, C diff --git a/tests/baselines/reference/localTypes1.symbols b/tests/baselines/reference/localTypes1.symbols index 3ee47086b26..528826a1d1b 100644 --- a/tests/baselines/reference/localTypes1.symbols +++ b/tests/baselines/reference/localTypes1.symbols @@ -1,357 +1,356 @@ === tests/cases/conformance/types/localTypes/localTypes1.ts === - function f1() { >f1 : Symbol(f1, Decl(localTypes1.ts, 0, 0)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 2, 12)) ->B : Symbol(E.B, Decl(localTypes1.ts, 3, 10)) ->C : Symbol(E.C, Decl(localTypes1.ts, 3, 13)) +>A : Symbol(E.A, Decl(localTypes1.ts, 1, 12)) +>B : Symbol(E.B, Decl(localTypes1.ts, 2, 10)) +>C : Symbol(E.C, Decl(localTypes1.ts, 2, 13)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 4, 5)) +>C : Symbol(C, Decl(localTypes1.ts, 3, 5)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 5, 13)) ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) +>x : Symbol(C.x, Decl(localTypes1.ts, 4, 13)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) } interface I { ->I : Symbol(I, Decl(localTypes1.ts, 7, 5)) +>I : Symbol(I, Decl(localTypes1.ts, 6, 5)) x: E; ->x : Symbol(I.x, Decl(localTypes1.ts, 8, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) +>x : Symbol(I.x, Decl(localTypes1.ts, 7, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) } type A = I[]; ->A : Symbol(A, Decl(localTypes1.ts, 10, 5)) ->I : Symbol(I, Decl(localTypes1.ts, 7, 5)) +>A : Symbol(A, Decl(localTypes1.ts, 9, 5)) +>I : Symbol(I, Decl(localTypes1.ts, 6, 5)) let a: A = [new C()]; ->a : Symbol(a, Decl(localTypes1.ts, 12, 7)) ->A : Symbol(A, Decl(localTypes1.ts, 10, 5)) ->C : Symbol(C, Decl(localTypes1.ts, 4, 5)) +>a : Symbol(a, Decl(localTypes1.ts, 11, 7)) +>A : Symbol(A, Decl(localTypes1.ts, 9, 5)) +>C : Symbol(C, Decl(localTypes1.ts, 3, 5)) a[0].x = E.B; ->a[0].x : Symbol(I.x, Decl(localTypes1.ts, 8, 17)) ->a : Symbol(a, Decl(localTypes1.ts, 12, 7)) ->x : Symbol(I.x, Decl(localTypes1.ts, 8, 17)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 3, 10)) ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) ->B : Symbol(E.B, Decl(localTypes1.ts, 3, 10)) +>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 7, 17)) +>a : Symbol(a, Decl(localTypes1.ts, 11, 7)) +>x : Symbol(I.x, Decl(localTypes1.ts, 7, 17)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 2, 10)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) +>B : Symbol(E.B, Decl(localTypes1.ts, 2, 10)) return a; ->a : Symbol(a, Decl(localTypes1.ts, 12, 7)) +>a : Symbol(a, Decl(localTypes1.ts, 11, 7)) } function f2() { ->f2 : Symbol(f2, Decl(localTypes1.ts, 15, 1)) +>f2 : Symbol(f2, Decl(localTypes1.ts, 14, 1)) function g() { ->g : Symbol(g, Decl(localTypes1.ts, 17, 15)) +>g : Symbol(g, Decl(localTypes1.ts, 16, 15)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 19, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 20, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 20, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 18, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 19, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 19, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 21, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 20, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 22, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) +>x : Symbol(C.x, Decl(localTypes1.ts, 21, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) } interface I { ->I : Symbol(I, Decl(localTypes1.ts, 24, 9)) +>I : Symbol(I, Decl(localTypes1.ts, 23, 9)) x: E; ->x : Symbol(I.x, Decl(localTypes1.ts, 25, 21)) ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) +>x : Symbol(I.x, Decl(localTypes1.ts, 24, 21)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) } type A = I[]; ->A : Symbol(A, Decl(localTypes1.ts, 27, 9)) ->I : Symbol(I, Decl(localTypes1.ts, 24, 9)) +>A : Symbol(A, Decl(localTypes1.ts, 26, 9)) +>I : Symbol(I, Decl(localTypes1.ts, 23, 9)) let a: A = [new C()]; ->a : Symbol(a, Decl(localTypes1.ts, 29, 11)) ->A : Symbol(A, Decl(localTypes1.ts, 27, 9)) ->C : Symbol(C, Decl(localTypes1.ts, 21, 9)) +>a : Symbol(a, Decl(localTypes1.ts, 28, 11)) +>A : Symbol(A, Decl(localTypes1.ts, 26, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 20, 9)) a[0].x = E.B; ->a[0].x : Symbol(I.x, Decl(localTypes1.ts, 25, 21)) ->a : Symbol(a, Decl(localTypes1.ts, 29, 11)) ->x : Symbol(I.x, Decl(localTypes1.ts, 25, 21)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 20, 14)) ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) ->B : Symbol(E.B, Decl(localTypes1.ts, 20, 14)) +>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 24, 21)) +>a : Symbol(a, Decl(localTypes1.ts, 28, 11)) +>x : Symbol(I.x, Decl(localTypes1.ts, 24, 21)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 19, 14)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) +>B : Symbol(E.B, Decl(localTypes1.ts, 19, 14)) return a; ->a : Symbol(a, Decl(localTypes1.ts, 29, 11)) +>a : Symbol(a, Decl(localTypes1.ts, 28, 11)) } return g(); ->g : Symbol(g, Decl(localTypes1.ts, 17, 15)) +>g : Symbol(g, Decl(localTypes1.ts, 16, 15)) } function f3(b: boolean) { ->f3 : Symbol(f3, Decl(localTypes1.ts, 34, 1)) ->b : Symbol(b, Decl(localTypes1.ts, 36, 12)) +>f3 : Symbol(f3, Decl(localTypes1.ts, 33, 1)) +>b : Symbol(b, Decl(localTypes1.ts, 35, 12)) if (true) { enum E { ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 38, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 39, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 37, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 38, 17)) } if (b) { ->b : Symbol(b, Decl(localTypes1.ts, 36, 12)) +>b : Symbol(b, Decl(localTypes1.ts, 35, 12)) class C { ->C : Symbol(C, Decl(localTypes1.ts, 41, 16)) +>C : Symbol(C, Decl(localTypes1.ts, 40, 16)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 42, 21)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(C.x, Decl(localTypes1.ts, 41, 21)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } interface I { ->I : Symbol(I, Decl(localTypes1.ts, 44, 13)) +>I : Symbol(I, Decl(localTypes1.ts, 43, 13)) x: E; ->x : Symbol(I.x, Decl(localTypes1.ts, 45, 25)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(I.x, Decl(localTypes1.ts, 44, 25)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } type A = I[]; ->A : Symbol(A, Decl(localTypes1.ts, 47, 13)) ->I : Symbol(I, Decl(localTypes1.ts, 44, 13)) +>A : Symbol(A, Decl(localTypes1.ts, 46, 13)) +>I : Symbol(I, Decl(localTypes1.ts, 43, 13)) let a: A = [new C()]; ->a : Symbol(a, Decl(localTypes1.ts, 49, 15)) ->A : Symbol(A, Decl(localTypes1.ts, 47, 13)) ->C : Symbol(C, Decl(localTypes1.ts, 41, 16)) +>a : Symbol(a, Decl(localTypes1.ts, 48, 15)) +>A : Symbol(A, Decl(localTypes1.ts, 46, 13)) +>C : Symbol(C, Decl(localTypes1.ts, 40, 16)) a[0].x = E.B; ->a[0].x : Symbol(I.x, Decl(localTypes1.ts, 45, 25)) ->a : Symbol(a, Decl(localTypes1.ts, 49, 15)) ->x : Symbol(I.x, Decl(localTypes1.ts, 45, 25)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) ->B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) +>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 44, 25)) +>a : Symbol(a, Decl(localTypes1.ts, 48, 15)) +>x : Symbol(I.x, Decl(localTypes1.ts, 44, 25)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) +>B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) return a; ->a : Symbol(a, Decl(localTypes1.ts, 49, 15)) +>a : Symbol(a, Decl(localTypes1.ts, 48, 15)) } else { class A { ->A : Symbol(A, Decl(localTypes1.ts, 53, 14)) +>A : Symbol(A, Decl(localTypes1.ts, 52, 14)) x: E; ->x : Symbol(A.x, Decl(localTypes1.ts, 54, 21)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(A.x, Decl(localTypes1.ts, 53, 21)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } interface J { ->J : Symbol(J, Decl(localTypes1.ts, 56, 13)) +>J : Symbol(J, Decl(localTypes1.ts, 55, 13)) x: E; ->x : Symbol(J.x, Decl(localTypes1.ts, 57, 25)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(J.x, Decl(localTypes1.ts, 56, 25)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } type C = J[]; ->C : Symbol(C, Decl(localTypes1.ts, 59, 13)) ->J : Symbol(J, Decl(localTypes1.ts, 56, 13)) +>C : Symbol(C, Decl(localTypes1.ts, 58, 13)) +>J : Symbol(J, Decl(localTypes1.ts, 55, 13)) let c: C = [new A()]; ->c : Symbol(c, Decl(localTypes1.ts, 61, 15)) ->C : Symbol(C, Decl(localTypes1.ts, 59, 13)) ->A : Symbol(A, Decl(localTypes1.ts, 53, 14)) +>c : Symbol(c, Decl(localTypes1.ts, 60, 15)) +>C : Symbol(C, Decl(localTypes1.ts, 58, 13)) +>A : Symbol(A, Decl(localTypes1.ts, 52, 14)) c[0].x = E.B; ->c[0].x : Symbol(J.x, Decl(localTypes1.ts, 57, 25)) ->c : Symbol(c, Decl(localTypes1.ts, 61, 15)) ->x : Symbol(J.x, Decl(localTypes1.ts, 57, 25)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) ->B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) +>c[0].x : Symbol(J.x, Decl(localTypes1.ts, 56, 25)) +>c : Symbol(c, Decl(localTypes1.ts, 60, 15)) +>x : Symbol(J.x, Decl(localTypes1.ts, 56, 25)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) +>B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) return c; ->c : Symbol(c, Decl(localTypes1.ts, 61, 15)) +>c : Symbol(c, Decl(localTypes1.ts, 60, 15)) } } } function f5() { ->f5 : Symbol(f5, Decl(localTypes1.ts, 66, 1)) +>f5 : Symbol(f5, Decl(localTypes1.ts, 65, 1)) var z1 = function () { ->z1 : Symbol(z1, Decl(localTypes1.ts, 69, 7)) +>z1 : Symbol(z1, Decl(localTypes1.ts, 68, 7)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 69, 26)) +>E : Symbol(E, Decl(localTypes1.ts, 68, 26)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 70, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 71, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 71, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 69, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 70, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 70, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 72, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 71, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 73, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 69, 26)) +>x : Symbol(C.x, Decl(localTypes1.ts, 72, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 68, 26)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 72, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 71, 9)) } var z2 = () => { ->z2 : Symbol(z2, Decl(localTypes1.ts, 78, 7)) +>z2 : Symbol(z2, Decl(localTypes1.ts, 77, 7)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 78, 20)) +>E : Symbol(E, Decl(localTypes1.ts, 77, 20)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 79, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 80, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 80, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 78, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 79, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 79, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 81, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 80, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 82, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 78, 20)) +>x : Symbol(C.x, Decl(localTypes1.ts, 81, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 77, 20)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 81, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 80, 9)) } } class A { ->A : Symbol(A, Decl(localTypes1.ts, 87, 1)) +>A : Symbol(A, Decl(localTypes1.ts, 86, 1)) constructor() { enum E { ->E : Symbol(E, Decl(localTypes1.ts, 90, 19)) +>E : Symbol(E, Decl(localTypes1.ts, 89, 19)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 91, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 92, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 92, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 90, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 91, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 91, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 93, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 92, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 94, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 90, 19)) +>x : Symbol(C.x, Decl(localTypes1.ts, 93, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 89, 19)) } } m() { ->m : Symbol(A.m, Decl(localTypes1.ts, 97, 5)) +>m : Symbol(A.m, Decl(localTypes1.ts, 96, 5)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 98, 9)) +>E : Symbol(E, Decl(localTypes1.ts, 97, 9)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 99, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 100, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 100, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 98, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 99, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 99, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 101, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 100, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 102, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 98, 9)) +>x : Symbol(C.x, Decl(localTypes1.ts, 101, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 97, 9)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 101, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 100, 9)) } get p() { ->p : Symbol(A.p, Decl(localTypes1.ts, 106, 5)) +>p : Symbol(A.p, Decl(localTypes1.ts, 105, 5)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 107, 13)) +>E : Symbol(E, Decl(localTypes1.ts, 106, 13)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 108, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 109, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 109, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 107, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 108, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 108, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 110, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 109, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 111, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 107, 13)) +>x : Symbol(C.x, Decl(localTypes1.ts, 110, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 106, 13)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 110, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 109, 9)) } } function f6() { ->f6 : Symbol(f6, Decl(localTypes1.ts, 116, 1)) +>f6 : Symbol(f6, Decl(localTypes1.ts, 115, 1)) class A { ->A : Symbol(A, Decl(localTypes1.ts, 118, 15)) +>A : Symbol(A, Decl(localTypes1.ts, 117, 15)) a: string; ->a : Symbol(A.a, Decl(localTypes1.ts, 119, 13)) +>a : Symbol(A.a, Decl(localTypes1.ts, 118, 13)) } function g() { ->g : Symbol(g, Decl(localTypes1.ts, 121, 5)) +>g : Symbol(g, Decl(localTypes1.ts, 120, 5)) class B extends A { ->B : Symbol(B, Decl(localTypes1.ts, 122, 18)) ->A : Symbol(A, Decl(localTypes1.ts, 118, 15)) +>B : Symbol(B, Decl(localTypes1.ts, 121, 18)) +>A : Symbol(A, Decl(localTypes1.ts, 117, 15)) b: string; ->b : Symbol(B.b, Decl(localTypes1.ts, 123, 27)) +>b : Symbol(B.b, Decl(localTypes1.ts, 122, 27)) } function h() { ->h : Symbol(h, Decl(localTypes1.ts, 125, 9)) +>h : Symbol(h, Decl(localTypes1.ts, 124, 9)) class C extends B { ->C : Symbol(C, Decl(localTypes1.ts, 126, 22)) ->B : Symbol(B, Decl(localTypes1.ts, 122, 18)) +>C : Symbol(C, Decl(localTypes1.ts, 125, 22)) +>B : Symbol(B, Decl(localTypes1.ts, 121, 18)) c: string; ->c : Symbol(C.c, Decl(localTypes1.ts, 127, 31)) +>c : Symbol(C.c, Decl(localTypes1.ts, 126, 31)) } var x = new C(); ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->C : Symbol(C, Decl(localTypes1.ts, 126, 22)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>C : Symbol(C, Decl(localTypes1.ts, 125, 22)) x.a = "a"; ->x.a : Symbol(A.a, Decl(localTypes1.ts, 119, 13)) ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->a : Symbol(A.a, Decl(localTypes1.ts, 119, 13)) +>x.a : Symbol(A.a, Decl(localTypes1.ts, 118, 13)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>a : Symbol(A.a, Decl(localTypes1.ts, 118, 13)) x.b = "b"; ->x.b : Symbol(B.b, Decl(localTypes1.ts, 123, 27)) ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->b : Symbol(B.b, Decl(localTypes1.ts, 123, 27)) +>x.b : Symbol(B.b, Decl(localTypes1.ts, 122, 27)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>b : Symbol(B.b, Decl(localTypes1.ts, 122, 27)) x.c = "c"; ->x.c : Symbol(C.c, Decl(localTypes1.ts, 127, 31)) ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->c : Symbol(C.c, Decl(localTypes1.ts, 127, 31)) +>x.c : Symbol(C.c, Decl(localTypes1.ts, 126, 31)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>c : Symbol(C.c, Decl(localTypes1.ts, 126, 31)) return x; ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) } return h(); ->h : Symbol(h, Decl(localTypes1.ts, 125, 9)) +>h : Symbol(h, Decl(localTypes1.ts, 124, 9)) } return g(); ->g : Symbol(g, Decl(localTypes1.ts, 121, 5)) +>g : Symbol(g, Decl(localTypes1.ts, 120, 5)) } diff --git a/tests/baselines/reference/localTypes1.types b/tests/baselines/reference/localTypes1.types index 7ac6896b9f3..73d9bde168e 100644 --- a/tests/baselines/reference/localTypes1.types +++ b/tests/baselines/reference/localTypes1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/localTypes/localTypes1.ts === - function f1() { >f1 : () => I[] diff --git a/tests/baselines/reference/localTypes4.errors.txt b/tests/baselines/reference/localTypes4.errors.txt index 4d08644ea89..cad9d30c933 100644 --- a/tests/baselines/reference/localTypes4.errors.txt +++ b/tests/baselines/reference/localTypes4.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/localTypes/localTypes4.ts(11,19): error TS2304: Cannot find name 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(11,23): error TS2304: Cannot find name 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(19,16): error TS2300: Duplicate identifier 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(20,19): error TS2300: Duplicate identifier 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(10,19): error TS2304: Cannot find name 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(10,23): error TS2304: Cannot find name 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(18,16): error TS2300: Duplicate identifier 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(19,19): error TS2300: Duplicate identifier 'T'. ==== tests/cases/conformance/types/localTypes/localTypes4.ts (4 errors) ==== - function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/baselines/reference/localTypes4.js b/tests/baselines/reference/localTypes4.js index 3b81175d2b6..8f51761a65a 100644 --- a/tests/baselines/reference/localTypes4.js +++ b/tests/baselines/reference/localTypes4.js @@ -1,5 +1,4 @@ //// [localTypes4.ts] - function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/baselines/reference/logicalAndOperatorStrictMode.js b/tests/baselines/reference/logicalAndOperatorStrictMode.js index ecb5bc16429..5dd95f2cdb6 100644 --- a/tests/baselines/reference/logicalAndOperatorStrictMode.js +++ b/tests/baselines/reference/logicalAndOperatorStrictMode.js @@ -1,5 +1,4 @@ //// [logicalAndOperatorStrictMode.ts] - const a = [0]; const s = ""; const x = 0; diff --git a/tests/baselines/reference/logicalAndOperatorStrictMode.symbols b/tests/baselines/reference/logicalAndOperatorStrictMode.symbols index e3425a26149..1da489b6639 100644 --- a/tests/baselines/reference/logicalAndOperatorStrictMode.symbols +++ b/tests/baselines/reference/logicalAndOperatorStrictMode.symbols @@ -1,351 +1,350 @@ === tests/cases/conformance/expressions/binaryOperators/logicalAndOperator/logicalAndOperatorStrictMode.ts === - const a = [0]; ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const s = ""; ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const x = 0; ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const b = false; ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const v: void = undefined; ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) >undefined : Symbol(undefined) const u = undefined; ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) >undefined : Symbol(undefined) const n = null; ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const z = s || x || u; ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const a1 = a && a; ->a1 : Symbol(a1, Decl(logicalAndOperatorStrictMode.ts, 10, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>a1 : Symbol(a1, Decl(logicalAndOperatorStrictMode.ts, 9, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const a2 = a && s; ->a2 : Symbol(a2, Decl(logicalAndOperatorStrictMode.ts, 11, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>a2 : Symbol(a2, Decl(logicalAndOperatorStrictMode.ts, 10, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const a3 = a && x; ->a3 : Symbol(a3, Decl(logicalAndOperatorStrictMode.ts, 12, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>a3 : Symbol(a3, Decl(logicalAndOperatorStrictMode.ts, 11, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const a4 = a && b; ->a4 : Symbol(a4, Decl(logicalAndOperatorStrictMode.ts, 13, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>a4 : Symbol(a4, Decl(logicalAndOperatorStrictMode.ts, 12, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const a5 = a && v; ->a5 : Symbol(a5, Decl(logicalAndOperatorStrictMode.ts, 14, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>a5 : Symbol(a5, Decl(logicalAndOperatorStrictMode.ts, 13, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const a6 = a && u; ->a6 : Symbol(a6, Decl(logicalAndOperatorStrictMode.ts, 15, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>a6 : Symbol(a6, Decl(logicalAndOperatorStrictMode.ts, 14, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const a7 = a && n; ->a7 : Symbol(a7, Decl(logicalAndOperatorStrictMode.ts, 16, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>a7 : Symbol(a7, Decl(logicalAndOperatorStrictMode.ts, 15, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const a8 = a && z; ->a8 : Symbol(a8, Decl(logicalAndOperatorStrictMode.ts, 17, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>a8 : Symbol(a8, Decl(logicalAndOperatorStrictMode.ts, 16, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const s1 = s && a; ->s1 : Symbol(s1, Decl(logicalAndOperatorStrictMode.ts, 19, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>s1 : Symbol(s1, Decl(logicalAndOperatorStrictMode.ts, 18, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const s2 = s && s; ->s2 : Symbol(s2, Decl(logicalAndOperatorStrictMode.ts, 20, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>s2 : Symbol(s2, Decl(logicalAndOperatorStrictMode.ts, 19, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const s3 = s && x; ->s3 : Symbol(s3, Decl(logicalAndOperatorStrictMode.ts, 21, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>s3 : Symbol(s3, Decl(logicalAndOperatorStrictMode.ts, 20, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const s4 = s && b; ->s4 : Symbol(s4, Decl(logicalAndOperatorStrictMode.ts, 22, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>s4 : Symbol(s4, Decl(logicalAndOperatorStrictMode.ts, 21, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const s5 = s && v; ->s5 : Symbol(s5, Decl(logicalAndOperatorStrictMode.ts, 23, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>s5 : Symbol(s5, Decl(logicalAndOperatorStrictMode.ts, 22, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const s6 = s && u; ->s6 : Symbol(s6, Decl(logicalAndOperatorStrictMode.ts, 24, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>s6 : Symbol(s6, Decl(logicalAndOperatorStrictMode.ts, 23, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const s7 = s && n; ->s7 : Symbol(s7, Decl(logicalAndOperatorStrictMode.ts, 25, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>s7 : Symbol(s7, Decl(logicalAndOperatorStrictMode.ts, 24, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const s8 = s && z; ->s8 : Symbol(s8, Decl(logicalAndOperatorStrictMode.ts, 26, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>s8 : Symbol(s8, Decl(logicalAndOperatorStrictMode.ts, 25, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const x1 = x && a; ->x1 : Symbol(x1, Decl(logicalAndOperatorStrictMode.ts, 28, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>x1 : Symbol(x1, Decl(logicalAndOperatorStrictMode.ts, 27, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const x2 = x && s; ->x2 : Symbol(x2, Decl(logicalAndOperatorStrictMode.ts, 29, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>x2 : Symbol(x2, Decl(logicalAndOperatorStrictMode.ts, 28, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const x3 = x && x; ->x3 : Symbol(x3, Decl(logicalAndOperatorStrictMode.ts, 30, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>x3 : Symbol(x3, Decl(logicalAndOperatorStrictMode.ts, 29, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const x4 = x && b; ->x4 : Symbol(x4, Decl(logicalAndOperatorStrictMode.ts, 31, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>x4 : Symbol(x4, Decl(logicalAndOperatorStrictMode.ts, 30, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const x5 = x && v; ->x5 : Symbol(x5, Decl(logicalAndOperatorStrictMode.ts, 32, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>x5 : Symbol(x5, Decl(logicalAndOperatorStrictMode.ts, 31, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const x6 = x && u; ->x6 : Symbol(x6, Decl(logicalAndOperatorStrictMode.ts, 33, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>x6 : Symbol(x6, Decl(logicalAndOperatorStrictMode.ts, 32, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const x7 = x && n; ->x7 : Symbol(x7, Decl(logicalAndOperatorStrictMode.ts, 34, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>x7 : Symbol(x7, Decl(logicalAndOperatorStrictMode.ts, 33, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const x8 = x && z; ->x8 : Symbol(x8, Decl(logicalAndOperatorStrictMode.ts, 35, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>x8 : Symbol(x8, Decl(logicalAndOperatorStrictMode.ts, 34, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const b1 = b && a; ->b1 : Symbol(b1, Decl(logicalAndOperatorStrictMode.ts, 37, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>b1 : Symbol(b1, Decl(logicalAndOperatorStrictMode.ts, 36, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const b2 = b && s; ->b2 : Symbol(b2, Decl(logicalAndOperatorStrictMode.ts, 38, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>b2 : Symbol(b2, Decl(logicalAndOperatorStrictMode.ts, 37, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const b3 = b && x; ->b3 : Symbol(b3, Decl(logicalAndOperatorStrictMode.ts, 39, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>b3 : Symbol(b3, Decl(logicalAndOperatorStrictMode.ts, 38, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const b4 = b && b; ->b4 : Symbol(b4, Decl(logicalAndOperatorStrictMode.ts, 40, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>b4 : Symbol(b4, Decl(logicalAndOperatorStrictMode.ts, 39, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const b5 = b && v; ->b5 : Symbol(b5, Decl(logicalAndOperatorStrictMode.ts, 41, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>b5 : Symbol(b5, Decl(logicalAndOperatorStrictMode.ts, 40, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const b6 = b && u; ->b6 : Symbol(b6, Decl(logicalAndOperatorStrictMode.ts, 42, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>b6 : Symbol(b6, Decl(logicalAndOperatorStrictMode.ts, 41, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const b7 = b && n; ->b7 : Symbol(b7, Decl(logicalAndOperatorStrictMode.ts, 43, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>b7 : Symbol(b7, Decl(logicalAndOperatorStrictMode.ts, 42, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const b8 = b && z; ->b8 : Symbol(b8, Decl(logicalAndOperatorStrictMode.ts, 44, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>b8 : Symbol(b8, Decl(logicalAndOperatorStrictMode.ts, 43, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const v1 = v && a; ->v1 : Symbol(v1, Decl(logicalAndOperatorStrictMode.ts, 46, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>v1 : Symbol(v1, Decl(logicalAndOperatorStrictMode.ts, 45, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const v2 = v && s; ->v2 : Symbol(v2, Decl(logicalAndOperatorStrictMode.ts, 47, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>v2 : Symbol(v2, Decl(logicalAndOperatorStrictMode.ts, 46, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const v3 = v && x; ->v3 : Symbol(v3, Decl(logicalAndOperatorStrictMode.ts, 48, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>v3 : Symbol(v3, Decl(logicalAndOperatorStrictMode.ts, 47, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const v4 = v && b; ->v4 : Symbol(v4, Decl(logicalAndOperatorStrictMode.ts, 49, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>v4 : Symbol(v4, Decl(logicalAndOperatorStrictMode.ts, 48, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const v5 = v && v; ->v5 : Symbol(v5, Decl(logicalAndOperatorStrictMode.ts, 50, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>v5 : Symbol(v5, Decl(logicalAndOperatorStrictMode.ts, 49, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const v6 = v && u; ->v6 : Symbol(v6, Decl(logicalAndOperatorStrictMode.ts, 51, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>v6 : Symbol(v6, Decl(logicalAndOperatorStrictMode.ts, 50, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const v7 = v && n; ->v7 : Symbol(v7, Decl(logicalAndOperatorStrictMode.ts, 52, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>v7 : Symbol(v7, Decl(logicalAndOperatorStrictMode.ts, 51, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const v8 = v && z; ->v8 : Symbol(v8, Decl(logicalAndOperatorStrictMode.ts, 53, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>v8 : Symbol(v8, Decl(logicalAndOperatorStrictMode.ts, 52, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const u1 = u && a; ->u1 : Symbol(u1, Decl(logicalAndOperatorStrictMode.ts, 55, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>u1 : Symbol(u1, Decl(logicalAndOperatorStrictMode.ts, 54, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const u2 = u && s; ->u2 : Symbol(u2, Decl(logicalAndOperatorStrictMode.ts, 56, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>u2 : Symbol(u2, Decl(logicalAndOperatorStrictMode.ts, 55, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const u3 = u && x; ->u3 : Symbol(u3, Decl(logicalAndOperatorStrictMode.ts, 57, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>u3 : Symbol(u3, Decl(logicalAndOperatorStrictMode.ts, 56, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const u4 = u && b; ->u4 : Symbol(u4, Decl(logicalAndOperatorStrictMode.ts, 58, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>u4 : Symbol(u4, Decl(logicalAndOperatorStrictMode.ts, 57, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const u5 = u && v; ->u5 : Symbol(u5, Decl(logicalAndOperatorStrictMode.ts, 59, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>u5 : Symbol(u5, Decl(logicalAndOperatorStrictMode.ts, 58, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const u6 = u && u; ->u6 : Symbol(u6, Decl(logicalAndOperatorStrictMode.ts, 60, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>u6 : Symbol(u6, Decl(logicalAndOperatorStrictMode.ts, 59, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const u7 = u && n; ->u7 : Symbol(u7, Decl(logicalAndOperatorStrictMode.ts, 61, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>u7 : Symbol(u7, Decl(logicalAndOperatorStrictMode.ts, 60, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const u8 = u && z; ->u8 : Symbol(u8, Decl(logicalAndOperatorStrictMode.ts, 62, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>u8 : Symbol(u8, Decl(logicalAndOperatorStrictMode.ts, 61, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const n1 = n && a; ->n1 : Symbol(n1, Decl(logicalAndOperatorStrictMode.ts, 64, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>n1 : Symbol(n1, Decl(logicalAndOperatorStrictMode.ts, 63, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const n2 = n && s; ->n2 : Symbol(n2, Decl(logicalAndOperatorStrictMode.ts, 65, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>n2 : Symbol(n2, Decl(logicalAndOperatorStrictMode.ts, 64, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const n3 = n && x; ->n3 : Symbol(n3, Decl(logicalAndOperatorStrictMode.ts, 66, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>n3 : Symbol(n3, Decl(logicalAndOperatorStrictMode.ts, 65, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const n4 = n && b; ->n4 : Symbol(n4, Decl(logicalAndOperatorStrictMode.ts, 67, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>n4 : Symbol(n4, Decl(logicalAndOperatorStrictMode.ts, 66, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const n5 = n && v; ->n5 : Symbol(n5, Decl(logicalAndOperatorStrictMode.ts, 68, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>n5 : Symbol(n5, Decl(logicalAndOperatorStrictMode.ts, 67, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const n6 = n && u; ->n6 : Symbol(n6, Decl(logicalAndOperatorStrictMode.ts, 69, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>n6 : Symbol(n6, Decl(logicalAndOperatorStrictMode.ts, 68, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const n7 = n && n; ->n7 : Symbol(n7, Decl(logicalAndOperatorStrictMode.ts, 70, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>n7 : Symbol(n7, Decl(logicalAndOperatorStrictMode.ts, 69, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const n8 = n && z; ->n8 : Symbol(n8, Decl(logicalAndOperatorStrictMode.ts, 71, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>n8 : Symbol(n8, Decl(logicalAndOperatorStrictMode.ts, 70, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const z1 = z && a; ->z1 : Symbol(z1, Decl(logicalAndOperatorStrictMode.ts, 73, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>z1 : Symbol(z1, Decl(logicalAndOperatorStrictMode.ts, 72, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const z2 = z && s; ->z2 : Symbol(z2, Decl(logicalAndOperatorStrictMode.ts, 74, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>z2 : Symbol(z2, Decl(logicalAndOperatorStrictMode.ts, 73, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const z3 = z && x; ->z3 : Symbol(z3, Decl(logicalAndOperatorStrictMode.ts, 75, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>z3 : Symbol(z3, Decl(logicalAndOperatorStrictMode.ts, 74, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const z4 = z && b; ->z4 : Symbol(z4, Decl(logicalAndOperatorStrictMode.ts, 76, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>z4 : Symbol(z4, Decl(logicalAndOperatorStrictMode.ts, 75, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const z5 = z && v; ->z5 : Symbol(z5, Decl(logicalAndOperatorStrictMode.ts, 77, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>z5 : Symbol(z5, Decl(logicalAndOperatorStrictMode.ts, 76, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const z6 = z && u; ->z6 : Symbol(z6, Decl(logicalAndOperatorStrictMode.ts, 78, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>z6 : Symbol(z6, Decl(logicalAndOperatorStrictMode.ts, 77, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const z7 = z && n; ->z7 : Symbol(z7, Decl(logicalAndOperatorStrictMode.ts, 79, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>z7 : Symbol(z7, Decl(logicalAndOperatorStrictMode.ts, 78, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const z8 = z && z; ->z8 : Symbol(z8, Decl(logicalAndOperatorStrictMode.ts, 80, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>z8 : Symbol(z8, Decl(logicalAndOperatorStrictMode.ts, 79, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) diff --git a/tests/baselines/reference/logicalAndOperatorStrictMode.types b/tests/baselines/reference/logicalAndOperatorStrictMode.types index 892da985120..2d7ef648aee 100644 --- a/tests/baselines/reference/logicalAndOperatorStrictMode.types +++ b/tests/baselines/reference/logicalAndOperatorStrictMode.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/binaryOperators/logicalAndOperator/logicalAndOperatorStrictMode.ts === - const a = [0]; >a : number[] >[0] : number[] diff --git a/tests/baselines/reference/malformedTags.js b/tests/baselines/reference/malformedTags.js index 33b2c1e6f41..320669c9462 100644 --- a/tests/baselines/reference/malformedTags.js +++ b/tests/baselines/reference/malformedTags.js @@ -1,5 +1,4 @@ //// [myFile02.js] - /** * Checks if `value` is classified as an `Array` object. * diff --git a/tests/baselines/reference/malformedTags.symbols b/tests/baselines/reference/malformedTags.symbols index df953a82497..cd98f2a59a3 100644 --- a/tests/baselines/reference/malformedTags.symbols +++ b/tests/baselines/reference/malformedTags.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/salsa/myFile02.js === - /** * Checks if `value` is classified as an `Array` object. * * @type Function */ var isArray = Array.isArray; ->isArray : Symbol(isArray, Decl(myFile02.js, 6, 3)) +>isArray : Symbol(isArray, Decl(myFile02.js, 5, 3)) >Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/malformedTags.types b/tests/baselines/reference/malformedTags.types index acf442f7cba..b4f7daecd8f 100644 --- a/tests/baselines/reference/malformedTags.types +++ b/tests/baselines/reference/malformedTags.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/myFile02.js === - /** * Checks if `value` is classified as an `Array` object. * diff --git a/tests/baselines/reference/mapOnTupleTypes01.js b/tests/baselines/reference/mapOnTupleTypes01.js index 9f22aa63753..565988bfd73 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.js +++ b/tests/baselines/reference/mapOnTupleTypes01.js @@ -1,5 +1,4 @@ //// [mapOnTupleTypes01.ts] - export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); // Length 1 diff --git a/tests/baselines/reference/mapOnTupleTypes01.symbols b/tests/baselines/reference/mapOnTupleTypes01.symbols index 1dbfca4a4c3..d0d263542c5 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.symbols +++ b/tests/baselines/reference/mapOnTupleTypes01.symbols @@ -1,119 +1,118 @@ === tests/cases/compiler/mapOnTupleTypes01.ts === - export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); ->mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 1, 10)) +>mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 0, 10)) >[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53)) // Length 1 let numTuple: [number] = [1]; ->numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) +>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 4, 3)) export let a = numTuple.map(x => x * x); ->a : Symbol(a, Decl(mapOnTupleTypes01.ts, 6, 10)) +>a : Symbol(a, Decl(mapOnTupleTypes01.ts, 5, 10)) >numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) +>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 4, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28)) // Length 2 let numNum: [number, number] = [ 100, 100]; ->numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) +>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 9, 3)) let strStr: [string, string] = ["hello", "hello"]; ->strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) +>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 10, 3)) let numStr: [number, string] = [ 100, "hello"]; ->numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) +>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 11, 3)) export let b = numNum.map(n => n * n); ->b : Symbol(b, Decl(mapOnTupleTypes01.ts, 14, 10)) +>b : Symbol(b, Decl(mapOnTupleTypes01.ts, 13, 10)) >numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) +>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 9, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26)) export let c = strStr.map(s => s.charCodeAt(0)); ->c : Symbol(c, Decl(mapOnTupleTypes01.ts, 15, 10)) +>c : Symbol(c, Decl(mapOnTupleTypes01.ts, 14, 10)) >strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) +>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 10, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) +>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 14, 26)) >s.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) +>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 14, 26)) >charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) export let d = numStr.map(x => x); ->d : Symbol(d, Decl(mapOnTupleTypes01.ts, 16, 10)) +>d : Symbol(d, Decl(mapOnTupleTypes01.ts, 15, 10)) >numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) +>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 11, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 15, 26)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 15, 26)) // Length 3 let numNumNum: [number, number, number] = [1, 2, 3]; ->numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) +>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 19, 3)) export let e = numNumNum.map(n => n * n); ->e : Symbol(e, Decl(mapOnTupleTypes01.ts, 22, 10)) +>e : Symbol(e, Decl(mapOnTupleTypes01.ts, 21, 10)) >numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) +>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 19, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29)) // Length 4 let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; ->numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) +>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 25, 3)) export let f = numNumNumNum.map(n => n * n); ->f : Symbol(f, Decl(mapOnTupleTypes01.ts, 28, 10)) +>f : Symbol(f, Decl(mapOnTupleTypes01.ts, 27, 10)) >numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) +>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 25, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32)) // Length 5 let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; ->numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3)) export let g = numNumNumNumNum.map(n => n * n); ->g : Symbol(g, Decl(mapOnTupleTypes01.ts, 34, 10)) +>g : Symbol(g, Decl(mapOnTupleTypes01.ts, 33, 10)) >numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35)) // Length 6 let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6]; ->numNumNumNumNumNum : Symbol(numNumNumNumNumNum, Decl(mapOnTupleTypes01.ts, 39, 3)) +>numNumNumNumNumNum : Symbol(numNumNumNumNumNum, Decl(mapOnTupleTypes01.ts, 38, 3)) export let h = numNumNumNumNum.map(n => n * n); ->h : Symbol(h, Decl(mapOnTupleTypes01.ts, 41, 10)) +>h : Symbol(h, Decl(mapOnTupleTypes01.ts, 40, 10)) >numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35)) diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types index 0a01ecfa380..700fdf45a21 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.types +++ b/tests/baselines/reference/mapOnTupleTypes01.types @@ -1,5 +1,4 @@ === tests/cases/compiler/mapOnTupleTypes01.ts === - export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); >mapOnLooseArrayLiteral : number[] >[1, 2, 3, 4].map(n => n * n) : number[] diff --git a/tests/baselines/reference/mapOnTupleTypes02.js b/tests/baselines/reference/mapOnTupleTypes02.js index ca835751a7a..2fd4daab16b 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.js +++ b/tests/baselines/reference/mapOnTupleTypes02.js @@ -1,5 +1,4 @@ //// [mapOnTupleTypes02.ts] - export type Point = [number, number]; export function increment(point: Point) { diff --git a/tests/baselines/reference/mapOnTupleTypes02.symbols b/tests/baselines/reference/mapOnTupleTypes02.symbols index da27a13d4f6..fc377efd8a2 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.symbols +++ b/tests/baselines/reference/mapOnTupleTypes02.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/mapOnTupleTypes02.ts === - export type Point = [number, number]; >Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) export function increment(point: Point) { ->increment : Symbol(increment, Decl(mapOnTupleTypes02.ts, 1, 37)) ->point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) +>increment : Symbol(increment, Decl(mapOnTupleTypes02.ts, 0, 37)) +>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 2, 26)) >Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) return point.map(d => d + 1); >point.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) +>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 2, 26)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) ->d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) +>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 3, 19)) +>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 3, 19)) } diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types index 3803e3c319e..2a2be82fc01 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.types +++ b/tests/baselines/reference/mapOnTupleTypes02.types @@ -1,5 +1,4 @@ === tests/cases/compiler/mapOnTupleTypes02.ts === - export type Point = [number, number]; >Point : [number, number] diff --git a/tests/baselines/reference/mappedTypeErrors.errors.txt b/tests/baselines/reference/mappedTypeErrors.errors.txt index c7571295521..3245f9932f0 100644 --- a/tests/baselines/reference/mappedTypeErrors.errors.txt +++ b/tests/baselines/reference/mappedTypeErrors.errors.txt @@ -1,56 +1,55 @@ -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(20,20): error TS2313: Type parameter 'P' has a circular constraint. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(21,20): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(22,20): error TS2322: Type 'Date' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(23,19): error TS2344: Type 'Date' does not satisfy the constraint 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(26,24): error TS2344: Type '"foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(27,24): error TS2344: Type '"name" | "foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(19,20): error TS2313: Type parameter 'P' has a circular constraint. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(20,20): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(21,20): error TS2322: Type 'Date' is not assignable to type 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(22,19): error TS2344: Type 'Date' does not satisfy the constraint 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(25,24): error TS2344: Type '"foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(26,24): error TS2344: Type '"name" | "foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type '"foo"' is not assignable to type '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(29,24): error TS2344: Type '"x" | "y"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(28,24): error TS2344: Type '"x" | "y"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type '"x"' is not assignable to type '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(31,24): error TS2344: Type 'undefined' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(34,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(30,24): error TS2344: Type 'undefined' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(33,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type 'T' is not assignable to type '"visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(38,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(37,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type 'string | number' is not assignable to type '"name" | "width" | "height" | "visible"'. Type 'string' is not assignable to type '"name" | "width" | "height" | "visible"'. Type 'T' is not assignable to type '"visible"'. Type 'string | number' is not assignable to type '"visible"'. Type 'string' is not assignable to type '"visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(60,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]?: T[P] | undefined; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(61,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]: T[P]; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(62,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]?: T[P] | undefined; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(67,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]: T[P][]; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(76,45): error TS2345: Argument of type '{ x: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(59,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]?: T[P] | undefined; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(60,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]: T[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(61,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]?: T[P] | undefined; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(66,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]: T[P][]; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(75,45): error TS2345: Argument of type '{ x: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. Property 'y' is missing in type '{ x: number; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(78,59): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(77,59): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. Object literal may only specify known properties, and 'z' does not exist in type 'Readonly<{ x: number; y: number; }>'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(84,58): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Partial<{ x: number; y: number; }>'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(83,58): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Partial<{ x: number; y: number; }>'. Object literal may only specify known properties, and 'z' does not exist in type 'Partial<{ x: number; y: number; }>'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(106,15): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(105,15): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. Types of property 'a' are incompatible. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(107,17): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(106,17): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. Object literal may only specify known properties, and 'c' does not exist in type 'Pick'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(124,12): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(123,12): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. Types of property 'a' are incompatible. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(125,14): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(124,14): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. Object literal may only specify known properties, and 'c' does not exist in type 'Pick'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(129,5): error TS2322: Type '{ a: string; }' is not assignable to type 'T2'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(128,5): error TS2322: Type '{ a: string; }' is not assignable to type 'T2'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(130,5): error TS2322: Type '{ a: string; }' is not assignable to type 'Partial'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(129,5): error TS2322: Type '{ a: string; }' is not assignable to type 'Partial'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(131,5): error TS2322: Type '{ a: string; }' is not assignable to type '{ [x: string]: any; a?: number | undefined; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(130,5): error TS2322: Type '{ a: string; }' is not assignable to type '{ [x: string]: any; a?: number | undefined; }'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(137,16): error TS2322: Type 'T' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(137,21): error TS2536: Type 'P' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(136,16): error TS2322: Type 'T' is not assignable to type 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(136,21): error TS2536: Type 'P' cannot be used to index type 'T'. ==== tests/cases/conformance/types/mapped/mappedTypeErrors.ts (26 errors) ==== - interface Shape { name: string; width: number; diff --git a/tests/baselines/reference/mappedTypeErrors.js b/tests/baselines/reference/mappedTypeErrors.js index f194b6193fc..dcaa737edd8 100644 --- a/tests/baselines/reference/mappedTypeErrors.js +++ b/tests/baselines/reference/mappedTypeErrors.js @@ -1,5 +1,4 @@ //// [mappedTypeErrors.ts] - interface Shape { name: string; width: number; diff --git a/tests/baselines/reference/mappedTypeModifiers.js b/tests/baselines/reference/mappedTypeModifiers.js index a247d18f2d4..e4d2c513d4c 100644 --- a/tests/baselines/reference/mappedTypeModifiers.js +++ b/tests/baselines/reference/mappedTypeModifiers.js @@ -1,5 +1,4 @@ //// [mappedTypeModifiers.ts] - type T = { a: number, b: string }; type TP = { a?: number, b?: string }; type TR = { readonly a: number, readonly b: string }; diff --git a/tests/baselines/reference/mappedTypeModifiers.symbols b/tests/baselines/reference/mappedTypeModifiers.symbols index b2b8faed4cf..2aa6492d99f 100644 --- a/tests/baselines/reference/mappedTypeModifiers.symbols +++ b/tests/baselines/reference/mappedTypeModifiers.symbols @@ -1,63 +1,62 @@ === tests/cases/conformance/types/mapped/mappedTypeModifiers.ts === - type T = { a: number, b: string }; >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 1, 10)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 1, 21)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 0, 10)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 0, 21)) type TP = { a?: number, b?: string }; ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 2, 11)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 2, 23)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 1, 11)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 1, 23)) type TR = { readonly a: number, readonly b: string }; ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 3, 11)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 3, 31)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 2, 11)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 2, 31)) type TPR = { readonly a?: number, readonly b?: string }; ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 4, 12)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 4, 33)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 3, 12)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 3, 33)) var v00: "a" | "b"; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) var v00: keyof T; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v00: keyof TP; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v00: keyof TR; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v00: keyof TPR; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) var v01: T; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v01: { [P in keyof T]: T[P] }; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 13, 12)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 12, 12)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 13, 12)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 12, 12)) var v01: Pick; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v01: Pick, keyof T>; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) @@ -65,368 +64,368 @@ var v01: Pick, keyof T>; >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v02: TP; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v02: { [P in keyof T]?: T[P] }; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 18, 12)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 17, 12)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 18, 12)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 17, 12)) var v02: Partial; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v02: { [P in keyof TP]: TP[P] } ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 20, 12)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 20, 12)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 19, 12)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 19, 12)) var v02: Pick; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v03: TR; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v03: { readonly [P in keyof T]: T[P] }; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 24, 21)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 23, 21)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 24, 21)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 23, 21)) var v03: Readonly; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v03: { [P in keyof TR]: TR[P] } ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 26, 12)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 26, 12)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 25, 12)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 25, 12)) var v03: Pick; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v04: TPR; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) var v04: { readonly [P in keyof T]?: T[P] }; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 30, 21)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 29, 21)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 30, 21)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 29, 21)) var v04: Partial; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v04: Readonly; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v04: Partial>; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v04: Readonly>; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v04: { [P in keyof TPR]: TPR[P] } ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 35, 12)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 35, 12)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 34, 12)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 34, 12)) var v04: Pick; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) type Boxified = { [P in keyof T]: { x: T[P] } }; ->Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 36, 28)) ->T : Symbol(T, Decl(mappedTypeModifiers.ts, 38, 14)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 38, 22)) ->T : Symbol(T, Decl(mappedTypeModifiers.ts, 38, 14)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 38, 38)) ->T : Symbol(T, Decl(mappedTypeModifiers.ts, 38, 14)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 38, 22)) +>Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 35, 28)) +>T : Symbol(T, Decl(mappedTypeModifiers.ts, 37, 14)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 37, 22)) +>T : Symbol(T, Decl(mappedTypeModifiers.ts, 37, 14)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 37, 38)) +>T : Symbol(T, Decl(mappedTypeModifiers.ts, 37, 14)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 37, 22)) type B = { a: { x: number }, b: { x: string } }; ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 40, 10)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 15)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 40, 28)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 33)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 39, 10)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 39, 15)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 39, 28)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 39, 33)) type BP = { a?: { x: number }, b?: { x: string } }; ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 41, 11)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 17)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 41, 30)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 36)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 40, 11)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 17)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 40, 30)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 36)) type BR = { readonly a: { x: number }, readonly b: { x: string } }; ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 42, 11)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 25)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 42, 38)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 52)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 41, 11)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 25)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 41, 38)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 52)) type BPR = { readonly a?: { x: number }, readonly b?: { x: string } }; ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 43, 12)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 43, 27)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 43, 40)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 43, 55)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 42, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 27)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 42, 40)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 55)) var b00: "a" | "b"; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) var b00: keyof B; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b00: keyof BP; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b00: keyof BR; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b00: keyof BPR; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) var b01: B; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b01: { [P in keyof B]: B[P] }; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 52, 12)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 52, 12)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 51, 12)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 51, 12)) var b01: Pick; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b01: Pick, keyof B>; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b02: BP; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b02: { [P in keyof B]?: B[P] }; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 57, 12)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 57, 12)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 56, 12)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 56, 12)) var b02: Partial; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b02: { [P in keyof BP]: BP[P] } ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 59, 12)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 59, 12)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 58, 12)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 58, 12)) var b02: Pick; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b03: BR; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b03: { readonly [P in keyof B]: B[P] }; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 63, 21)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 63, 21)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 62, 21)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 62, 21)) var b03: Readonly; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b03: { [P in keyof BR]: BR[P] } ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 65, 12)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 65, 12)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 64, 12)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 64, 12)) var b03: Pick; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b04: BPR; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) var b04: { readonly [P in keyof B]?: B[P] }; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 69, 21)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 69, 21)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 68, 21)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 68, 21)) var b04: Partial
; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b04: Readonly; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b04: Partial>; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b04: Readonly>; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b04: { [P in keyof BPR]: BPR[P] } ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 74, 12)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 74, 12)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 73, 12)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 73, 12)) var b04: Pick; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) type Foo = { prop: number, [x: string]: number }; ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) ->prop : Symbol(prop, Decl(mappedTypeModifiers.ts, 77, 12)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 77, 28)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) +>prop : Symbol(prop, Decl(mappedTypeModifiers.ts, 76, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 76, 28)) function f1(x: Partial) { ->f1 : Symbol(f1, Decl(mappedTypeModifiers.ts, 77, 49)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 79, 12)) +>f1 : Symbol(f1, Decl(mappedTypeModifiers.ts, 76, 49)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 78, 12)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 79, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 78, 12)) >prop : Symbol(prop) (x["other"] || 0).toFixed(); >(x["other"] || 0).toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 79, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 78, 12)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } function f2(x: Readonly) { ->f2 : Symbol(f2, Decl(mappedTypeModifiers.ts, 82, 1)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 84, 12)) +>f2 : Symbol(f2, Decl(mappedTypeModifiers.ts, 81, 1)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 83, 12)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 84, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 83, 12)) >prop : Symbol(prop) x["other"].toFixed(); >x["other"].toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 84, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 83, 12)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } function f3(x: Boxified) { ->f3 : Symbol(f3, Decl(mappedTypeModifiers.ts, 87, 1)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 89, 12)) ->Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 36, 28)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) +>f3 : Symbol(f3, Decl(mappedTypeModifiers.ts, 86, 1)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 88, 12)) +>Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 35, 28)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 89, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 88, 12)) >prop : Symbol(prop) x["other"].x.toFixed(); >x["other"].x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x["other"].x : Symbol(x, Decl(mappedTypeModifiers.ts, 38, 38)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 89, 12)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 38, 38)) +>x["other"].x : Symbol(x, Decl(mappedTypeModifiers.ts, 37, 38)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 88, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 37, 38)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } function f4(x: { [P in keyof Foo]: Foo[P] }) { ->f4 : Symbol(f4, Decl(mappedTypeModifiers.ts, 92, 1)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 94, 12)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 94, 18)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 94, 18)) +>f4 : Symbol(f4, Decl(mappedTypeModifiers.ts, 91, 1)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 93, 12)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 93, 18)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 93, 18)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 94, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 93, 12)) >prop : Symbol(prop) x["other"].toFixed(); >x["other"].toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 94, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 93, 12)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/mappedTypeModifiers.types b/tests/baselines/reference/mappedTypeModifiers.types index 7771de023f1..b7c5c08ac52 100644 --- a/tests/baselines/reference/mappedTypeModifiers.types +++ b/tests/baselines/reference/mappedTypeModifiers.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypeModifiers.ts === - type T = { a: number, b: string }; >T : T >a : number diff --git a/tests/baselines/reference/mappedTypeRelationships.errors.txt b/tests/baselines/reference/mappedTypeRelationships.errors.txt index 22f56dacaf6..997e7ab4250 100644 --- a/tests/baselines/reference/mappedTypeRelationships.errors.txt +++ b/tests/baselines/reference/mappedTypeRelationships.errors.txt @@ -1,54 +1,53 @@ -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(12,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(11,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(17,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(16,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,5): error TS2536: Type 'keyof U' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(22,5): error TS2322: Type 'T[keyof U]' is not assignable to type 'U[keyof U]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(20,5): error TS2536: Type 'keyof U' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,5): error TS2322: Type 'T[keyof U]' is not assignable to type 'U[keyof U]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(22,12): error TS2536: Type 'keyof U' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,5): error TS2536: Type 'K' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(27,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,12): error TS2536: Type 'keyof U' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(25,5): error TS2536: Type 'K' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(27,12): error TS2536: Type 'K' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(31,5): error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,12): error TS2536: Type 'K' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(30,5): error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'. Type 'undefined' is not assignable to type 'T[keyof T]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(36,5): error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(35,5): error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'. Type 'undefined' is not assignable to type 'T[K]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(41,5): error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(40,5): error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'. Type 'undefined' is not assignable to type 'T[keyof T]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(42,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(41,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'. Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(46,5): error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(45,5): error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'. Type 'undefined' is not assignable to type 'T[K]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(47,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(46,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'. Type 'T[K]' is not assignable to type 'U[K]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(52,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(57,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(62,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(67,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(71,5): error TS2322: Type 'Partial' is not assignable to type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(76,5): error TS2322: Type 'Partial' is not assignable to type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(126,5): error TS2322: Type 'Partial' is not assignable to type 'Identity'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(142,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(51,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(56,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(61,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(66,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(70,5): error TS2322: Type 'Partial' is not assignable to type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(75,5): error TS2322: Type 'Partial' is not assignable to type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(125,5): error TS2322: Type 'Partial' is not assignable to type 'Identity'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(141,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. Type 'T[P]' is not assignable to type 'U[P]'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(147,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(146,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. Type 'keyof U' is not assignable to type 'keyof T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(152,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: T[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(151,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: T[P]; }'. Type 'keyof T' is not assignable to type 'K'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(157,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(156,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. Type 'keyof U' is not assignable to type 'K'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(162,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(161,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. Type 'keyof T' is not assignable to type 'K'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in K]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(166,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in K]: U[P]; }'. Type 'T[P]' is not assignable to type 'U[P]'. Type 'T' is not assignable to type 'U'. ==== tests/cases/conformance/types/mapped/mappedTypeRelationships.ts (27 errors) ==== - function f1(x: T, k: keyof T) { return x[k]; } diff --git a/tests/baselines/reference/mappedTypeRelationships.js b/tests/baselines/reference/mappedTypeRelationships.js index 2476b72cef6..3580007137e 100644 --- a/tests/baselines/reference/mappedTypeRelationships.js +++ b/tests/baselines/reference/mappedTypeRelationships.js @@ -1,5 +1,4 @@ //// [mappedTypeRelationships.ts] - function f1(x: T, k: keyof T) { return x[k]; } diff --git a/tests/baselines/reference/mappedTypes1.js b/tests/baselines/reference/mappedTypes1.js index 4dd8f172179..67a7b8db9b2 100644 --- a/tests/baselines/reference/mappedTypes1.js +++ b/tests/baselines/reference/mappedTypes1.js @@ -1,5 +1,4 @@ //// [mappedTypes1.ts] - type Item = { a: string, b: number, c: boolean }; type T00 = { [P in "x" | "y"]: number }; diff --git a/tests/baselines/reference/mappedTypes1.symbols b/tests/baselines/reference/mappedTypes1.symbols index e8c09b25989..e012b49ddf4 100644 --- a/tests/baselines/reference/mappedTypes1.symbols +++ b/tests/baselines/reference/mappedTypes1.symbols @@ -1,165 +1,164 @@ === tests/cases/conformance/types/mapped/mappedTypes1.ts === - type Item = { a: string, b: number, c: boolean }; >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->a : Symbol(a, Decl(mappedTypes1.ts, 1, 13)) ->b : Symbol(b, Decl(mappedTypes1.ts, 1, 24)) ->c : Symbol(c, Decl(mappedTypes1.ts, 1, 35)) +>a : Symbol(a, Decl(mappedTypes1.ts, 0, 13)) +>b : Symbol(b, Decl(mappedTypes1.ts, 0, 24)) +>c : Symbol(c, Decl(mappedTypes1.ts, 0, 35)) type T00 = { [P in "x" | "y"]: number }; ->T00 : Symbol(T00, Decl(mappedTypes1.ts, 1, 49)) ->P : Symbol(P, Decl(mappedTypes1.ts, 3, 14)) +>T00 : Symbol(T00, Decl(mappedTypes1.ts, 0, 49)) +>P : Symbol(P, Decl(mappedTypes1.ts, 2, 14)) type T01 = { [P in "x" | "y"]: P }; ->T01 : Symbol(T01, Decl(mappedTypes1.ts, 3, 40)) ->P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) ->P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) +>T01 : Symbol(T01, Decl(mappedTypes1.ts, 2, 40)) +>P : Symbol(P, Decl(mappedTypes1.ts, 3, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 3, 14)) type T02 = { [P in "a" | "b"]: Item[P]; } ->T02 : Symbol(T02, Decl(mappedTypes1.ts, 4, 35)) ->P : Symbol(P, Decl(mappedTypes1.ts, 5, 14)) +>T02 : Symbol(T02, Decl(mappedTypes1.ts, 3, 35)) +>P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 5, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) type T03 = { [P in keyof Item]: Date }; ->T03 : Symbol(T03, Decl(mappedTypes1.ts, 5, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 6, 14)) +>T03 : Symbol(T03, Decl(mappedTypes1.ts, 4, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 5, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type T10 = { [P in keyof Item]: Item[P] }; ->T10 : Symbol(T10, Decl(mappedTypes1.ts, 6, 39)) ->P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) +>T10 : Symbol(T10, Decl(mappedTypes1.ts, 5, 39)) +>P : Symbol(P, Decl(mappedTypes1.ts, 7, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 7, 14)) type T11 = { [P in keyof Item]?: Item[P] }; ->T11 : Symbol(T11, Decl(mappedTypes1.ts, 8, 42)) ->P : Symbol(P, Decl(mappedTypes1.ts, 9, 14)) +>T11 : Symbol(T11, Decl(mappedTypes1.ts, 7, 42)) +>P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 9, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) type T12 = { readonly [P in keyof Item]: Item[P] }; ->T12 : Symbol(T12, Decl(mappedTypes1.ts, 9, 43)) ->P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) +>T12 : Symbol(T12, Decl(mappedTypes1.ts, 8, 43)) +>P : Symbol(P, Decl(mappedTypes1.ts, 9, 23)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) +>P : Symbol(P, Decl(mappedTypes1.ts, 9, 23)) type T13 = { readonly [P in keyof Item]?: Item[P] }; ->T13 : Symbol(T13, Decl(mappedTypes1.ts, 10, 51)) ->P : Symbol(P, Decl(mappedTypes1.ts, 11, 23)) +>T13 : Symbol(T13, Decl(mappedTypes1.ts, 9, 51)) +>P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 11, 23)) +>P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) type T20 = { [P in keyof Item]: Item[P] | null }; ->T20 : Symbol(T20, Decl(mappedTypes1.ts, 11, 52)) ->P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) +>T20 : Symbol(T20, Decl(mappedTypes1.ts, 10, 52)) +>P : Symbol(P, Decl(mappedTypes1.ts, 12, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 12, 14)) type T21 = { [P in keyof Item]: Array }; ->T21 : Symbol(T21, Decl(mappedTypes1.ts, 13, 49)) ->P : Symbol(P, Decl(mappedTypes1.ts, 14, 14)) +>T21 : Symbol(T21, Decl(mappedTypes1.ts, 12, 49)) +>P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 14, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) type T30 = { [P in keyof any]: void }; ->T30 : Symbol(T30, Decl(mappedTypes1.ts, 14, 49)) ->P : Symbol(P, Decl(mappedTypes1.ts, 16, 14)) +>T30 : Symbol(T30, Decl(mappedTypes1.ts, 13, 49)) +>P : Symbol(P, Decl(mappedTypes1.ts, 15, 14)) type T31 = { [P in keyof string]: void }; ->T31 : Symbol(T31, Decl(mappedTypes1.ts, 16, 38)) ->P : Symbol(P, Decl(mappedTypes1.ts, 17, 14)) +>T31 : Symbol(T31, Decl(mappedTypes1.ts, 15, 38)) +>P : Symbol(P, Decl(mappedTypes1.ts, 16, 14)) type T32 = { [P in keyof number]: void }; ->T32 : Symbol(T32, Decl(mappedTypes1.ts, 17, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 18, 14)) +>T32 : Symbol(T32, Decl(mappedTypes1.ts, 16, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 17, 14)) type T33 = { [P in keyof boolean]: void }; ->T33 : Symbol(T33, Decl(mappedTypes1.ts, 18, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 19, 14)) +>T33 : Symbol(T33, Decl(mappedTypes1.ts, 17, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 18, 14)) type T34 = { [P in keyof undefined]: void }; ->T34 : Symbol(T34, Decl(mappedTypes1.ts, 19, 42)) ->P : Symbol(P, Decl(mappedTypes1.ts, 20, 14)) +>T34 : Symbol(T34, Decl(mappedTypes1.ts, 18, 42)) +>P : Symbol(P, Decl(mappedTypes1.ts, 19, 14)) type T35 = { [P in keyof null]: void }; ->T35 : Symbol(T35, Decl(mappedTypes1.ts, 20, 44)) ->P : Symbol(P, Decl(mappedTypes1.ts, 21, 14)) +>T35 : Symbol(T35, Decl(mappedTypes1.ts, 19, 44)) +>P : Symbol(P, Decl(mappedTypes1.ts, 20, 14)) type T36 = { [P in keyof void]: void }; ->T36 : Symbol(T36, Decl(mappedTypes1.ts, 21, 39)) ->P : Symbol(P, Decl(mappedTypes1.ts, 22, 14)) +>T36 : Symbol(T36, Decl(mappedTypes1.ts, 20, 39)) +>P : Symbol(P, Decl(mappedTypes1.ts, 21, 14)) type T37 = { [P in keyof symbol]: void }; ->T37 : Symbol(T37, Decl(mappedTypes1.ts, 22, 39)) ->P : Symbol(P, Decl(mappedTypes1.ts, 23, 14)) +>T37 : Symbol(T37, Decl(mappedTypes1.ts, 21, 39)) +>P : Symbol(P, Decl(mappedTypes1.ts, 22, 14)) type T38 = { [P in keyof never]: void }; ->T38 : Symbol(T38, Decl(mappedTypes1.ts, 23, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 24, 14)) +>T38 : Symbol(T38, Decl(mappedTypes1.ts, 22, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 23, 14)) type T40 = { [P in string]: void }; ->T40 : Symbol(T40, Decl(mappedTypes1.ts, 24, 40)) ->P : Symbol(P, Decl(mappedTypes1.ts, 26, 14)) +>T40 : Symbol(T40, Decl(mappedTypes1.ts, 23, 40)) +>P : Symbol(P, Decl(mappedTypes1.ts, 25, 14)) type T43 = { [P in "a" | "b"]: void }; ->T43 : Symbol(T43, Decl(mappedTypes1.ts, 26, 35)) ->P : Symbol(P, Decl(mappedTypes1.ts, 27, 14)) +>T43 : Symbol(T43, Decl(mappedTypes1.ts, 25, 35)) +>P : Symbol(P, Decl(mappedTypes1.ts, 26, 14)) type T44 = { [P in "a" | "b" | "0" | "1"]: void }; ->T44 : Symbol(T44, Decl(mappedTypes1.ts, 27, 38)) ->P : Symbol(P, Decl(mappedTypes1.ts, 28, 14)) +>T44 : Symbol(T44, Decl(mappedTypes1.ts, 26, 38)) +>P : Symbol(P, Decl(mappedTypes1.ts, 27, 14)) type T47 = { [P in string | "a" | "b" | "0" | "1"]: void }; ->T47 : Symbol(T47, Decl(mappedTypes1.ts, 28, 50)) ->P : Symbol(P, Decl(mappedTypes1.ts, 29, 14)) +>T47 : Symbol(T47, Decl(mappedTypes1.ts, 27, 50)) +>P : Symbol(P, Decl(mappedTypes1.ts, 28, 14)) declare function f1(): { [P in keyof T1]: void }; ->f1 : Symbol(f1, Decl(mappedTypes1.ts, 29, 59)) ->T1 : Symbol(T1, Decl(mappedTypes1.ts, 31, 20)) ->P : Symbol(P, Decl(mappedTypes1.ts, 31, 30)) ->T1 : Symbol(T1, Decl(mappedTypes1.ts, 31, 20)) +>f1 : Symbol(f1, Decl(mappedTypes1.ts, 28, 59)) +>T1 : Symbol(T1, Decl(mappedTypes1.ts, 30, 20)) +>P : Symbol(P, Decl(mappedTypes1.ts, 30, 30)) +>T1 : Symbol(T1, Decl(mappedTypes1.ts, 30, 20)) declare function f2(): { [P in keyof T1]: void }; ->f2 : Symbol(f2, Decl(mappedTypes1.ts, 31, 53)) +>f2 : Symbol(f2, Decl(mappedTypes1.ts, 30, 53)) +>T1 : Symbol(T1, Decl(mappedTypes1.ts, 31, 20)) +>P : Symbol(P, Decl(mappedTypes1.ts, 31, 45)) +>T1 : Symbol(T1, Decl(mappedTypes1.ts, 31, 20)) + +declare function f3(): { [P in keyof T1]: void }; +>f3 : Symbol(f3, Decl(mappedTypes1.ts, 31, 68)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 32, 20)) >P : Symbol(P, Decl(mappedTypes1.ts, 32, 45)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 32, 20)) -declare function f3(): { [P in keyof T1]: void }; ->f3 : Symbol(f3, Decl(mappedTypes1.ts, 32, 68)) +declare function f4(): { [P in keyof T1]: void }; +>f4 : Symbol(f4, Decl(mappedTypes1.ts, 32, 68)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 33, 20)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >P : Symbol(P, Decl(mappedTypes1.ts, 33, 45)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 33, 20)) -declare function f4(): { [P in keyof T1]: void }; ->f4 : Symbol(f4, Decl(mappedTypes1.ts, 33, 68)) ->T1 : Symbol(T1, Decl(mappedTypes1.ts, 34, 20)) ->Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->P : Symbol(P, Decl(mappedTypes1.ts, 34, 45)) ->T1 : Symbol(T1, Decl(mappedTypes1.ts, 34, 20)) - let x1 = f1(); ->x1 : Symbol(x1, Decl(mappedTypes1.ts, 36, 3)) ->f1 : Symbol(f1, Decl(mappedTypes1.ts, 29, 59)) +>x1 : Symbol(x1, Decl(mappedTypes1.ts, 35, 3)) +>f1 : Symbol(f1, Decl(mappedTypes1.ts, 28, 59)) let x2 = f2(); ->x2 : Symbol(x2, Decl(mappedTypes1.ts, 37, 3)) ->f2 : Symbol(f2, Decl(mappedTypes1.ts, 31, 53)) +>x2 : Symbol(x2, Decl(mappedTypes1.ts, 36, 3)) +>f2 : Symbol(f2, Decl(mappedTypes1.ts, 30, 53)) let x3 = f3(); ->x3 : Symbol(x3, Decl(mappedTypes1.ts, 38, 3)) ->f3 : Symbol(f3, Decl(mappedTypes1.ts, 32, 68)) +>x3 : Symbol(x3, Decl(mappedTypes1.ts, 37, 3)) +>f3 : Symbol(f3, Decl(mappedTypes1.ts, 31, 68)) let x4 = f4(); ->x4 : Symbol(x4, Decl(mappedTypes1.ts, 39, 3)) ->f4 : Symbol(f4, Decl(mappedTypes1.ts, 33, 68)) +>x4 : Symbol(x4, Decl(mappedTypes1.ts, 38, 3)) +>f4 : Symbol(f4, Decl(mappedTypes1.ts, 32, 68)) diff --git a/tests/baselines/reference/mappedTypes1.types b/tests/baselines/reference/mappedTypes1.types index a9a7f53a899..66aae568364 100644 --- a/tests/baselines/reference/mappedTypes1.types +++ b/tests/baselines/reference/mappedTypes1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes1.ts === - type Item = { a: string, b: number, c: boolean }; >Item : Item >a : string diff --git a/tests/baselines/reference/mappedTypes2.js b/tests/baselines/reference/mappedTypes2.js index 84d052b6287..4122cf575c6 100644 --- a/tests/baselines/reference/mappedTypes2.js +++ b/tests/baselines/reference/mappedTypes2.js @@ -1,5 +1,4 @@ //// [mappedTypes2.ts] - function verifyLibTypes() { var x1: Partial; var x1: { [P in keyof T]?: T[P] }; diff --git a/tests/baselines/reference/mappedTypes2.symbols b/tests/baselines/reference/mappedTypes2.symbols index 079a56243c5..7d9727daedd 100644 --- a/tests/baselines/reference/mappedTypes2.symbols +++ b/tests/baselines/reference/mappedTypes2.symbols @@ -1,353 +1,352 @@ === tests/cases/conformance/types/mapped/mappedTypes2.ts === - function verifyLibTypes() { >verifyLibTypes : Symbol(verifyLibTypes, Decl(mappedTypes2.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->U : Symbol(U, Decl(mappedTypes2.ts, 1, 45)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>U : Symbol(U, Decl(mappedTypes2.ts, 0, 45)) var x1: Partial; ->x1 : Symbol(x1, Decl(mappedTypes2.ts, 2, 7), Decl(mappedTypes2.ts, 3, 7)) +>x1 : Symbol(x1, Decl(mappedTypes2.ts, 1, 7), Decl(mappedTypes2.ts, 2, 7)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) var x1: { [P in keyof T]?: T[P] }; ->x1 : Symbol(x1, Decl(mappedTypes2.ts, 2, 7), Decl(mappedTypes2.ts, 3, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 3, 15)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->P : Symbol(P, Decl(mappedTypes2.ts, 3, 15)) +>x1 : Symbol(x1, Decl(mappedTypes2.ts, 1, 7), Decl(mappedTypes2.ts, 2, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 2, 15)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>P : Symbol(P, Decl(mappedTypes2.ts, 2, 15)) var x2: Readonly; ->x2 : Symbol(x2, Decl(mappedTypes2.ts, 4, 7), Decl(mappedTypes2.ts, 5, 7)) +>x2 : Symbol(x2, Decl(mappedTypes2.ts, 3, 7), Decl(mappedTypes2.ts, 4, 7)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) var x2: { readonly [P in keyof T]: T[P] }; ->x2 : Symbol(x2, Decl(mappedTypes2.ts, 4, 7), Decl(mappedTypes2.ts, 5, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 5, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->P : Symbol(P, Decl(mappedTypes2.ts, 5, 24)) +>x2 : Symbol(x2, Decl(mappedTypes2.ts, 3, 7), Decl(mappedTypes2.ts, 4, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 4, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>P : Symbol(P, Decl(mappedTypes2.ts, 4, 24)) var x3: Pick; ->x3 : Symbol(x3, Decl(mappedTypes2.ts, 6, 7), Decl(mappedTypes2.ts, 7, 7)) +>x3 : Symbol(x3, Decl(mappedTypes2.ts, 5, 7), Decl(mappedTypes2.ts, 6, 7)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) var x3: { [P in K]: T[P] }; ->x3 : Symbol(x3, Decl(mappedTypes2.ts, 6, 7), Decl(mappedTypes2.ts, 7, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 7, 15)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->P : Symbol(P, Decl(mappedTypes2.ts, 7, 15)) +>x3 : Symbol(x3, Decl(mappedTypes2.ts, 5, 7), Decl(mappedTypes2.ts, 6, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 6, 15)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>P : Symbol(P, Decl(mappedTypes2.ts, 6, 15)) var x4: Record; ->x4 : Symbol(x4, Decl(mappedTypes2.ts, 8, 7), Decl(mappedTypes2.ts, 9, 7)) +>x4 : Symbol(x4, Decl(mappedTypes2.ts, 7, 7), Decl(mappedTypes2.ts, 8, 7)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->U : Symbol(U, Decl(mappedTypes2.ts, 1, 45)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>U : Symbol(U, Decl(mappedTypes2.ts, 0, 45)) var x4: { [P in K]: U }; ->x4 : Symbol(x4, Decl(mappedTypes2.ts, 8, 7), Decl(mappedTypes2.ts, 9, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 9, 15)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->U : Symbol(U, Decl(mappedTypes2.ts, 1, 45)) +>x4 : Symbol(x4, Decl(mappedTypes2.ts, 7, 7), Decl(mappedTypes2.ts, 8, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 8, 15)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>U : Symbol(U, Decl(mappedTypes2.ts, 0, 45)) } type Proxy = { ->Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 10, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 12, 11)) +>Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 9, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 11, 11)) get(): T; ->get : Symbol(get, Decl(mappedTypes2.ts, 12, 17)) ->T : Symbol(T, Decl(mappedTypes2.ts, 12, 11)) +>get : Symbol(get, Decl(mappedTypes2.ts, 11, 17)) +>T : Symbol(T, Decl(mappedTypes2.ts, 11, 11)) set(value: T): void; ->set : Symbol(set, Decl(mappedTypes2.ts, 13, 13)) ->value : Symbol(value, Decl(mappedTypes2.ts, 14, 8)) ->T : Symbol(T, Decl(mappedTypes2.ts, 12, 11)) +>set : Symbol(set, Decl(mappedTypes2.ts, 12, 13)) +>value : Symbol(value, Decl(mappedTypes2.ts, 13, 8)) +>T : Symbol(T, Decl(mappedTypes2.ts, 11, 11)) } type Proxify = { ->Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 15, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 17, 13)) +>Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 14, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 16, 13)) [P in keyof T]: Proxy; ->P : Symbol(P, Decl(mappedTypes2.ts, 18, 5)) ->T : Symbol(T, Decl(mappedTypes2.ts, 17, 13)) ->Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 10, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 17, 13)) ->P : Symbol(P, Decl(mappedTypes2.ts, 18, 5)) +>P : Symbol(P, Decl(mappedTypes2.ts, 17, 5)) +>T : Symbol(T, Decl(mappedTypes2.ts, 16, 13)) +>Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 9, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 16, 13)) +>P : Symbol(P, Decl(mappedTypes2.ts, 17, 5)) } type DeepReadonly = { ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 19, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 21, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 18, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 20, 18)) readonly [P in keyof T]: DeepReadonly; ->P : Symbol(P, Decl(mappedTypes2.ts, 22, 14)) ->T : Symbol(T, Decl(mappedTypes2.ts, 21, 18)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 19, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 21, 18)) ->P : Symbol(P, Decl(mappedTypes2.ts, 22, 14)) +>P : Symbol(P, Decl(mappedTypes2.ts, 21, 14)) +>T : Symbol(T, Decl(mappedTypes2.ts, 20, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 18, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 20, 18)) +>P : Symbol(P, Decl(mappedTypes2.ts, 21, 14)) }; declare function assign(obj: T, props: Partial): void; ->assign : Symbol(assign, Decl(mappedTypes2.ts, 23, 2)) +>assign : Symbol(assign, Decl(mappedTypes2.ts, 22, 2)) +>T : Symbol(T, Decl(mappedTypes2.ts, 24, 24)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 24, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 24, 24)) +>props : Symbol(props, Decl(mappedTypes2.ts, 24, 34)) +>Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(mappedTypes2.ts, 24, 24)) + +declare function freeze(obj: T): Readonly; +>freeze : Symbol(freeze, Decl(mappedTypes2.ts, 24, 60)) >T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) >obj : Symbol(obj, Decl(mappedTypes2.ts, 25, 27)) >T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) ->props : Symbol(props, Decl(mappedTypes2.ts, 25, 34)) ->Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) +>Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) -declare function freeze(obj: T): Readonly; ->freeze : Symbol(freeze, Decl(mappedTypes2.ts, 25, 60)) ->T : Symbol(T, Decl(mappedTypes2.ts, 26, 24)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 26, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 26, 24)) ->Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 26, 24)) - declare function pick(obj: T, ...keys: K[]): Pick; ->pick : Symbol(pick, Decl(mappedTypes2.ts, 26, 48)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->K : Symbol(K, Decl(mappedTypes2.ts, 27, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 27, 44)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->keys : Symbol(keys, Decl(mappedTypes2.ts, 27, 51)) ->K : Symbol(K, Decl(mappedTypes2.ts, 27, 24)) +>pick : Symbol(pick, Decl(mappedTypes2.ts, 25, 48)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>K : Symbol(K, Decl(mappedTypes2.ts, 26, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 26, 44)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>keys : Symbol(keys, Decl(mappedTypes2.ts, 26, 51)) +>K : Symbol(K, Decl(mappedTypes2.ts, 26, 24)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->K : Symbol(K, Decl(mappedTypes2.ts, 27, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>K : Symbol(K, Decl(mappedTypes2.ts, 26, 24)) declare function mapObject(obj: Record, f: (x: T) => U): Record; ->mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 27, 78)) ->K : Symbol(K, Decl(mappedTypes2.ts, 28, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 28, 44)) ->U : Symbol(U, Decl(mappedTypes2.ts, 28, 47)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 28, 51)) +>mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 26, 78)) +>K : Symbol(K, Decl(mappedTypes2.ts, 27, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 27, 44)) +>U : Symbol(U, Decl(mappedTypes2.ts, 27, 47)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 27, 51)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(mappedTypes2.ts, 28, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 28, 44)) ->f : Symbol(f, Decl(mappedTypes2.ts, 28, 69)) ->x : Symbol(x, Decl(mappedTypes2.ts, 28, 74)) ->T : Symbol(T, Decl(mappedTypes2.ts, 28, 44)) ->U : Symbol(U, Decl(mappedTypes2.ts, 28, 47)) +>K : Symbol(K, Decl(mappedTypes2.ts, 27, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 27, 44)) +>f : Symbol(f, Decl(mappedTypes2.ts, 27, 69)) +>x : Symbol(x, Decl(mappedTypes2.ts, 27, 74)) +>T : Symbol(T, Decl(mappedTypes2.ts, 27, 44)) +>U : Symbol(U, Decl(mappedTypes2.ts, 27, 47)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(mappedTypes2.ts, 28, 27)) ->U : Symbol(U, Decl(mappedTypes2.ts, 28, 47)) +>K : Symbol(K, Decl(mappedTypes2.ts, 27, 27)) +>U : Symbol(U, Decl(mappedTypes2.ts, 27, 47)) declare function proxify(obj: T): Proxify; ->proxify : Symbol(proxify, Decl(mappedTypes2.ts, 28, 100)) ->T : Symbol(T, Decl(mappedTypes2.ts, 29, 25)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 29, 28)) ->T : Symbol(T, Decl(mappedTypes2.ts, 29, 25)) ->Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 15, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 29, 25)) +>proxify : Symbol(proxify, Decl(mappedTypes2.ts, 27, 100)) +>T : Symbol(T, Decl(mappedTypes2.ts, 28, 25)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 28, 28)) +>T : Symbol(T, Decl(mappedTypes2.ts, 28, 25)) +>Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 14, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 28, 25)) interface Point { ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) x: number; ->x : Symbol(Point.x, Decl(mappedTypes2.ts, 31, 17)) +>x : Symbol(Point.x, Decl(mappedTypes2.ts, 30, 17)) y: number; ->y : Symbol(Point.y, Decl(mappedTypes2.ts, 32, 14)) +>y : Symbol(Point.y, Decl(mappedTypes2.ts, 31, 14)) } interface Shape { ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) name: string; ->name : Symbol(Shape.name, Decl(mappedTypes2.ts, 36, 17)) +>name : Symbol(Shape.name, Decl(mappedTypes2.ts, 35, 17)) width: number; ->width : Symbol(Shape.width, Decl(mappedTypes2.ts, 37, 17)) +>width : Symbol(Shape.width, Decl(mappedTypes2.ts, 36, 17)) height: number; ->height : Symbol(Shape.height, Decl(mappedTypes2.ts, 38, 18)) +>height : Symbol(Shape.height, Decl(mappedTypes2.ts, 37, 18)) location: Point; ->location : Symbol(Shape.location, Decl(mappedTypes2.ts, 39, 19)) ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>location : Symbol(Shape.location, Decl(mappedTypes2.ts, 38, 19)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) } interface PartialShape { ->PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 41, 1)) +>PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 40, 1)) name?: string; ->name : Symbol(PartialShape.name, Decl(mappedTypes2.ts, 43, 24)) +>name : Symbol(PartialShape.name, Decl(mappedTypes2.ts, 42, 24)) width?: number; ->width : Symbol(PartialShape.width, Decl(mappedTypes2.ts, 44, 18)) +>width : Symbol(PartialShape.width, Decl(mappedTypes2.ts, 43, 18)) height?: number; ->height : Symbol(PartialShape.height, Decl(mappedTypes2.ts, 45, 19)) +>height : Symbol(PartialShape.height, Decl(mappedTypes2.ts, 44, 19)) location?: Point; ->location : Symbol(PartialShape.location, Decl(mappedTypes2.ts, 46, 20)) ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>location : Symbol(PartialShape.location, Decl(mappedTypes2.ts, 45, 20)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) } interface ReadonlyShape { ->ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 48, 1)) +>ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 47, 1)) readonly name: string; ->name : Symbol(ReadonlyShape.name, Decl(mappedTypes2.ts, 50, 25)) +>name : Symbol(ReadonlyShape.name, Decl(mappedTypes2.ts, 49, 25)) readonly width: number; ->width : Symbol(ReadonlyShape.width, Decl(mappedTypes2.ts, 51, 26)) +>width : Symbol(ReadonlyShape.width, Decl(mappedTypes2.ts, 50, 26)) readonly height: number; ->height : Symbol(ReadonlyShape.height, Decl(mappedTypes2.ts, 52, 27)) +>height : Symbol(ReadonlyShape.height, Decl(mappedTypes2.ts, 51, 27)) readonly location: Point; ->location : Symbol(ReadonlyShape.location, Decl(mappedTypes2.ts, 53, 28)) ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>location : Symbol(ReadonlyShape.location, Decl(mappedTypes2.ts, 52, 28)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) } function f0(s1: Shape, s2: Shape) { ->f0 : Symbol(f0, Decl(mappedTypes2.ts, 55, 1)) ->s1 : Symbol(s1, Decl(mappedTypes2.ts, 57, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) ->s2 : Symbol(s2, Decl(mappedTypes2.ts, 57, 22)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f0 : Symbol(f0, Decl(mappedTypes2.ts, 54, 1)) +>s1 : Symbol(s1, Decl(mappedTypes2.ts, 56, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) +>s2 : Symbol(s2, Decl(mappedTypes2.ts, 56, 22)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) assign(s1, { name: "circle" }); ->assign : Symbol(assign, Decl(mappedTypes2.ts, 23, 2)) ->s1 : Symbol(s1, Decl(mappedTypes2.ts, 57, 12)) ->name : Symbol(name, Decl(mappedTypes2.ts, 58, 16)) +>assign : Symbol(assign, Decl(mappedTypes2.ts, 22, 2)) +>s1 : Symbol(s1, Decl(mappedTypes2.ts, 56, 12)) +>name : Symbol(name, Decl(mappedTypes2.ts, 57, 16)) assign(s2, { width: 10, height: 20 }); ->assign : Symbol(assign, Decl(mappedTypes2.ts, 23, 2)) ->s2 : Symbol(s2, Decl(mappedTypes2.ts, 57, 22)) ->width : Symbol(width, Decl(mappedTypes2.ts, 59, 16)) ->height : Symbol(height, Decl(mappedTypes2.ts, 59, 27)) +>assign : Symbol(assign, Decl(mappedTypes2.ts, 22, 2)) +>s2 : Symbol(s2, Decl(mappedTypes2.ts, 56, 22)) +>width : Symbol(width, Decl(mappedTypes2.ts, 58, 16)) +>height : Symbol(height, Decl(mappedTypes2.ts, 58, 27)) } function f1(shape: Shape) { ->f1 : Symbol(f1, Decl(mappedTypes2.ts, 60, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 62, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f1 : Symbol(f1, Decl(mappedTypes2.ts, 59, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 61, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var frozen: ReadonlyShape; ->frozen : Symbol(frozen, Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7), Decl(mappedTypes2.ts, 65, 7)) ->ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 48, 1)) +>frozen : Symbol(frozen, Decl(mappedTypes2.ts, 62, 7), Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7)) +>ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 47, 1)) var frozen: Readonly; ->frozen : Symbol(frozen, Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7), Decl(mappedTypes2.ts, 65, 7)) +>frozen : Symbol(frozen, Decl(mappedTypes2.ts, 62, 7), Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var frozen = freeze(shape); ->frozen : Symbol(frozen, Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7), Decl(mappedTypes2.ts, 65, 7)) ->freeze : Symbol(freeze, Decl(mappedTypes2.ts, 25, 60)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 62, 12)) +>frozen : Symbol(frozen, Decl(mappedTypes2.ts, 62, 7), Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7)) +>freeze : Symbol(freeze, Decl(mappedTypes2.ts, 24, 60)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 61, 12)) } function f2(shape: Shape) { ->f2 : Symbol(f2, Decl(mappedTypes2.ts, 66, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 68, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f2 : Symbol(f2, Decl(mappedTypes2.ts, 65, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 67, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var partial: PartialShape; ->partial : Symbol(partial, Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7), Decl(mappedTypes2.ts, 71, 7)) ->PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 41, 1)) +>partial : Symbol(partial, Decl(mappedTypes2.ts, 68, 7), Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7)) +>PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 40, 1)) var partial: Partial; ->partial : Symbol(partial, Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7), Decl(mappedTypes2.ts, 71, 7)) +>partial : Symbol(partial, Decl(mappedTypes2.ts, 68, 7), Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var partial: Partial = {}; ->partial : Symbol(partial, Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7), Decl(mappedTypes2.ts, 71, 7)) +>partial : Symbol(partial, Decl(mappedTypes2.ts, 68, 7), Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) } function f3(shape: Shape) { ->f3 : Symbol(f3, Decl(mappedTypes2.ts, 72, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 74, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f3 : Symbol(f3, Decl(mappedTypes2.ts, 71, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 73, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) const x = pick(shape, "name", "location"); // { name: string, location: Point } ->x : Symbol(x, Decl(mappedTypes2.ts, 75, 9)) ->pick : Symbol(pick, Decl(mappedTypes2.ts, 26, 48)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 74, 12)) +>x : Symbol(x, Decl(mappedTypes2.ts, 74, 9)) +>pick : Symbol(pick, Decl(mappedTypes2.ts, 25, 48)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 73, 12)) } function f4() { ->f4 : Symbol(f4, Decl(mappedTypes2.ts, 76, 1)) +>f4 : Symbol(f4, Decl(mappedTypes2.ts, 75, 1)) const rec = { foo: "hello", bar: "world", baz: "bye" }; ->rec : Symbol(rec, Decl(mappedTypes2.ts, 79, 9)) ->foo : Symbol(foo, Decl(mappedTypes2.ts, 79, 17)) ->bar : Symbol(bar, Decl(mappedTypes2.ts, 79, 31)) ->baz : Symbol(baz, Decl(mappedTypes2.ts, 79, 45)) +>rec : Symbol(rec, Decl(mappedTypes2.ts, 78, 9)) +>foo : Symbol(foo, Decl(mappedTypes2.ts, 78, 17)) +>bar : Symbol(bar, Decl(mappedTypes2.ts, 78, 31)) +>baz : Symbol(baz, Decl(mappedTypes2.ts, 78, 45)) const lengths = mapObject(rec, s => s.length); // { foo: number, bar: number, baz: number } ->lengths : Symbol(lengths, Decl(mappedTypes2.ts, 80, 9)) ->mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 27, 78)) ->rec : Symbol(rec, Decl(mappedTypes2.ts, 79, 9)) ->s : Symbol(s, Decl(mappedTypes2.ts, 80, 34)) +>lengths : Symbol(lengths, Decl(mappedTypes2.ts, 79, 9)) +>mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 26, 78)) +>rec : Symbol(rec, Decl(mappedTypes2.ts, 78, 9)) +>s : Symbol(s, Decl(mappedTypes2.ts, 79, 34)) >s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(mappedTypes2.ts, 80, 34)) +>s : Symbol(s, Decl(mappedTypes2.ts, 79, 34)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } function f5(shape: Shape) { ->f5 : Symbol(f5, Decl(mappedTypes2.ts, 81, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 83, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f5 : Symbol(f5, Decl(mappedTypes2.ts, 80, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 82, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) const p = proxify(shape); ->p : Symbol(p, Decl(mappedTypes2.ts, 84, 9)) ->proxify : Symbol(proxify, Decl(mappedTypes2.ts, 28, 100)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 83, 12)) +>p : Symbol(p, Decl(mappedTypes2.ts, 83, 9)) +>proxify : Symbol(proxify, Decl(mappedTypes2.ts, 27, 100)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 82, 12)) let name = p.name.get(); ->name : Symbol(name, Decl(mappedTypes2.ts, 85, 7)) ->p.name.get : Symbol(get, Decl(mappedTypes2.ts, 12, 17)) +>name : Symbol(name, Decl(mappedTypes2.ts, 84, 7)) +>p.name.get : Symbol(get, Decl(mappedTypes2.ts, 11, 17)) >p.name : Symbol(name) ->p : Symbol(p, Decl(mappedTypes2.ts, 84, 9)) +>p : Symbol(p, Decl(mappedTypes2.ts, 83, 9)) >name : Symbol(name) ->get : Symbol(get, Decl(mappedTypes2.ts, 12, 17)) +>get : Symbol(get, Decl(mappedTypes2.ts, 11, 17)) p.width.set(42); ->p.width.set : Symbol(set, Decl(mappedTypes2.ts, 13, 13)) +>p.width.set : Symbol(set, Decl(mappedTypes2.ts, 12, 13)) >p.width : Symbol(width) ->p : Symbol(p, Decl(mappedTypes2.ts, 84, 9)) +>p : Symbol(p, Decl(mappedTypes2.ts, 83, 9)) >width : Symbol(width) ->set : Symbol(set, Decl(mappedTypes2.ts, 13, 13)) +>set : Symbol(set, Decl(mappedTypes2.ts, 12, 13)) } function f6(shape: DeepReadonly) { ->f6 : Symbol(f6, Decl(mappedTypes2.ts, 87, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 89, 12)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 19, 1)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f6 : Symbol(f6, Decl(mappedTypes2.ts, 86, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 88, 12)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 18, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) let name = shape.name; // string ->name : Symbol(name, Decl(mappedTypes2.ts, 90, 7)) +>name : Symbol(name, Decl(mappedTypes2.ts, 89, 7)) >shape.name : Symbol(name) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 89, 12)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 88, 12)) >name : Symbol(name) let location = shape.location; // DeepReadonly ->location : Symbol(location, Decl(mappedTypes2.ts, 91, 7)) +>location : Symbol(location, Decl(mappedTypes2.ts, 90, 7)) >shape.location : Symbol(location) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 89, 12)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 88, 12)) >location : Symbol(location) let x = location.x; // number ->x : Symbol(x, Decl(mappedTypes2.ts, 92, 7)) +>x : Symbol(x, Decl(mappedTypes2.ts, 91, 7)) >location.x : Symbol(x) ->location : Symbol(location, Decl(mappedTypes2.ts, 91, 7)) +>location : Symbol(location, Decl(mappedTypes2.ts, 90, 7)) >x : Symbol(x) } diff --git a/tests/baselines/reference/mappedTypes2.types b/tests/baselines/reference/mappedTypes2.types index f082069f569..7c54fffcb08 100644 --- a/tests/baselines/reference/mappedTypes2.types +++ b/tests/baselines/reference/mappedTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes2.ts === - function verifyLibTypes() { >verifyLibTypes : () => void >T : T diff --git a/tests/baselines/reference/mappedTypes3.js b/tests/baselines/reference/mappedTypes3.js index 712822e8728..b839e02d3a3 100644 --- a/tests/baselines/reference/mappedTypes3.js +++ b/tests/baselines/reference/mappedTypes3.js @@ -1,5 +1,4 @@ //// [mappedTypes3.ts] - class Box

{ value: P; } diff --git a/tests/baselines/reference/mappedTypes3.symbols b/tests/baselines/reference/mappedTypes3.symbols index 3d909c8e532..683c764f0f4 100644 --- a/tests/baselines/reference/mappedTypes3.symbols +++ b/tests/baselines/reference/mappedTypes3.symbols @@ -1,135 +1,134 @@ === tests/cases/conformance/types/mapped/mappedTypes3.ts === - class Box

{ >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes3.ts, 1, 10)) +>P : Symbol(P, Decl(mappedTypes3.ts, 0, 10)) value: P; ->value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) ->P : Symbol(P, Decl(mappedTypes3.ts, 1, 10)) +>value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) +>P : Symbol(P, Decl(mappedTypes3.ts, 0, 10)) } type Boxified = { ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 5, 14)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 4, 14)) [K in keyof T]: Box; ->K : Symbol(K, Decl(mappedTypes3.ts, 6, 5)) ->T : Symbol(T, Decl(mappedTypes3.ts, 5, 14)) +>K : Symbol(K, Decl(mappedTypes3.ts, 5, 5)) +>T : Symbol(T, Decl(mappedTypes3.ts, 4, 14)) >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes3.ts, 5, 14)) ->K : Symbol(K, Decl(mappedTypes3.ts, 6, 5)) +>T : Symbol(T, Decl(mappedTypes3.ts, 4, 14)) +>K : Symbol(K, Decl(mappedTypes3.ts, 5, 5)) } declare function boxify(obj: T): Boxified; ->boxify : Symbol(boxify, Decl(mappedTypes3.ts, 7, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 9, 24)) ->obj : Symbol(obj, Decl(mappedTypes3.ts, 9, 27)) ->T : Symbol(T, Decl(mappedTypes3.ts, 9, 24)) ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 9, 24)) +>boxify : Symbol(boxify, Decl(mappedTypes3.ts, 6, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 8, 24)) +>obj : Symbol(obj, Decl(mappedTypes3.ts, 8, 27)) +>T : Symbol(T, Decl(mappedTypes3.ts, 8, 24)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 8, 24)) declare function unboxify(obj: Boxified): T; ->unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 9, 48)) ->T : Symbol(T, Decl(mappedTypes3.ts, 10, 26)) ->obj : Symbol(obj, Decl(mappedTypes3.ts, 10, 29)) ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 10, 26)) ->T : Symbol(T, Decl(mappedTypes3.ts, 10, 26)) +>unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 8, 48)) +>T : Symbol(T, Decl(mappedTypes3.ts, 9, 26)) +>obj : Symbol(obj, Decl(mappedTypes3.ts, 9, 29)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 9, 26)) +>T : Symbol(T, Decl(mappedTypes3.ts, 9, 26)) interface Bacon { ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) isPerfect: boolean; ->isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) +>isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) weight: number; ->weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 13, 23)) +>weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 12, 23)) } interface BoxifiedBacon { ->BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 15, 1)) +>BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 14, 1)) isPerfect: Box; ->isPerfect : Symbol(BoxifiedBacon.isPerfect, Decl(mappedTypes3.ts, 17, 25)) +>isPerfect : Symbol(BoxifiedBacon.isPerfect, Decl(mappedTypes3.ts, 16, 25)) >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) weight: Box; ->weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 18, 28)) +>weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 17, 28)) >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) } function f1(b: Bacon) { ->f1 : Symbol(f1, Decl(mappedTypes3.ts, 20, 1)) ->b : Symbol(b, Decl(mappedTypes3.ts, 22, 12)) ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) +>f1 : Symbol(f1, Decl(mappedTypes3.ts, 19, 1)) +>b : Symbol(b, Decl(mappedTypes3.ts, 21, 12)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) let bb = boxify(b); ->bb : Symbol(bb, Decl(mappedTypes3.ts, 23, 7)) ->boxify : Symbol(boxify, Decl(mappedTypes3.ts, 7, 1)) ->b : Symbol(b, Decl(mappedTypes3.ts, 22, 12)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 22, 7)) +>boxify : Symbol(boxify, Decl(mappedTypes3.ts, 6, 1)) +>b : Symbol(b, Decl(mappedTypes3.ts, 21, 12)) let isPerfect = bb.isPerfect.value; ->isPerfect : Symbol(isPerfect, Decl(mappedTypes3.ts, 24, 7)) ->bb.isPerfect.value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>isPerfect : Symbol(isPerfect, Decl(mappedTypes3.ts, 23, 7)) +>bb.isPerfect.value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) >bb.isPerfect : Symbol(isPerfect) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 23, 7)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 22, 7)) >isPerfect : Symbol(isPerfect) ->value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) let weight = bb.weight.value; ->weight : Symbol(weight, Decl(mappedTypes3.ts, 25, 7)) ->bb.weight.value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>weight : Symbol(weight, Decl(mappedTypes3.ts, 24, 7)) +>bb.weight.value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) >bb.weight : Symbol(weight) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 23, 7)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 22, 7)) >weight : Symbol(weight) ->value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) } function f2(bb: Boxified) { ->f2 : Symbol(f2, Decl(mappedTypes3.ts, 26, 1)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 28, 12)) ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) +>f2 : Symbol(f2, Decl(mappedTypes3.ts, 25, 1)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 27, 12)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) let b = unboxify(bb); // Infer Bacon for T ->b : Symbol(b, Decl(mappedTypes3.ts, 29, 7)) ->unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 9, 48)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 28, 12)) +>b : Symbol(b, Decl(mappedTypes3.ts, 28, 7)) +>unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 8, 48)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 27, 12)) let bool = b.isPerfect; ->bool : Symbol(bool, Decl(mappedTypes3.ts, 30, 7)) ->b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) ->b : Symbol(b, Decl(mappedTypes3.ts, 29, 7)) ->isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) +>bool : Symbol(bool, Decl(mappedTypes3.ts, 29, 7)) +>b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) +>b : Symbol(b, Decl(mappedTypes3.ts, 28, 7)) +>isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) let weight = b.weight; ->weight : Symbol(weight, Decl(mappedTypes3.ts, 31, 7)) ->b.weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 13, 23)) ->b : Symbol(b, Decl(mappedTypes3.ts, 29, 7)) ->weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 13, 23)) +>weight : Symbol(weight, Decl(mappedTypes3.ts, 30, 7)) +>b.weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 12, 23)) +>b : Symbol(b, Decl(mappedTypes3.ts, 28, 7)) +>weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 12, 23)) } function f3(bb: BoxifiedBacon) { ->f3 : Symbol(f3, Decl(mappedTypes3.ts, 32, 1)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 34, 12)) ->BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 15, 1)) +>f3 : Symbol(f3, Decl(mappedTypes3.ts, 31, 1)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 33, 12)) +>BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 14, 1)) let b = unboxify(bb); // Explicit type parameter required ->b : Symbol(b, Decl(mappedTypes3.ts, 35, 7)) ->unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 9, 48)) ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 34, 12)) +>b : Symbol(b, Decl(mappedTypes3.ts, 34, 7)) +>unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 8, 48)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 33, 12)) let bool = b.isPerfect; ->bool : Symbol(bool, Decl(mappedTypes3.ts, 36, 7)) ->b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) ->b : Symbol(b, Decl(mappedTypes3.ts, 35, 7)) ->isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) +>bool : Symbol(bool, Decl(mappedTypes3.ts, 35, 7)) +>b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) +>b : Symbol(b, Decl(mappedTypes3.ts, 34, 7)) +>isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) let weight = bb.weight; ->weight : Symbol(weight, Decl(mappedTypes3.ts, 37, 7)) ->bb.weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 18, 28)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 34, 12)) ->weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 18, 28)) +>weight : Symbol(weight, Decl(mappedTypes3.ts, 36, 7)) +>bb.weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 17, 28)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 33, 12)) +>weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 17, 28)) } diff --git a/tests/baselines/reference/mappedTypes3.types b/tests/baselines/reference/mappedTypes3.types index 36471938d75..3428e8b98bd 100644 --- a/tests/baselines/reference/mappedTypes3.types +++ b/tests/baselines/reference/mappedTypes3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes3.ts === - class Box

{ >Box : Box

>P : P diff --git a/tests/baselines/reference/mappedTypes4.js b/tests/baselines/reference/mappedTypes4.js index 963538d2269..395d6490b4e 100644 --- a/tests/baselines/reference/mappedTypes4.js +++ b/tests/baselines/reference/mappedTypes4.js @@ -1,5 +1,4 @@ //// [mappedTypes4.ts] - type Box = { }; diff --git a/tests/baselines/reference/mappedTypes4.symbols b/tests/baselines/reference/mappedTypes4.symbols index ed108b47d78..6c42cb5dea0 100644 --- a/tests/baselines/reference/mappedTypes4.symbols +++ b/tests/baselines/reference/mappedTypes4.symbols @@ -1,229 +1,228 @@ === tests/cases/conformance/types/mapped/mappedTypes4.ts === - type Box = { >Box : Symbol(Box, Decl(mappedTypes4.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes4.ts, 1, 9)) +>T : Symbol(T, Decl(mappedTypes4.ts, 0, 9)) }; type Boxified = { ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 4, 14)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 3, 14)) [P in keyof T]: Box; ->P : Symbol(P, Decl(mappedTypes4.ts, 5, 5)) ->T : Symbol(T, Decl(mappedTypes4.ts, 4, 14)) +>P : Symbol(P, Decl(mappedTypes4.ts, 4, 5)) +>T : Symbol(T, Decl(mappedTypes4.ts, 3, 14)) >Box : Symbol(Box, Decl(mappedTypes4.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes4.ts, 4, 14)) ->P : Symbol(P, Decl(mappedTypes4.ts, 5, 5)) +>T : Symbol(T, Decl(mappedTypes4.ts, 3, 14)) +>P : Symbol(P, Decl(mappedTypes4.ts, 4, 5)) }; function boxify(obj: T): Boxified { ->boxify : Symbol(boxify, Decl(mappedTypes4.ts, 6, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) +>boxify : Symbol(boxify, Decl(mappedTypes4.ts, 5, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) if (typeof obj === "object") { ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) let result = {} as Boxified; ->result : Symbol(result, Decl(mappedTypes4.ts, 10, 11)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) +>result : Symbol(result, Decl(mappedTypes4.ts, 9, 11)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) for (let k in obj) { ->k : Symbol(k, Decl(mappedTypes4.ts, 11, 16)) ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) +>k : Symbol(k, Decl(mappedTypes4.ts, 10, 16)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) result[k] = { value: obj[k] }; ->result : Symbol(result, Decl(mappedTypes4.ts, 10, 11)) ->k : Symbol(k, Decl(mappedTypes4.ts, 11, 16)) ->value : Symbol(value, Decl(mappedTypes4.ts, 12, 25)) ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) ->k : Symbol(k, Decl(mappedTypes4.ts, 11, 16)) +>result : Symbol(result, Decl(mappedTypes4.ts, 9, 11)) +>k : Symbol(k, Decl(mappedTypes4.ts, 10, 16)) +>value : Symbol(value, Decl(mappedTypes4.ts, 11, 25)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) +>k : Symbol(k, Decl(mappedTypes4.ts, 10, 16)) } return result; ->result : Symbol(result, Decl(mappedTypes4.ts, 10, 11)) +>result : Symbol(result, Decl(mappedTypes4.ts, 9, 11)) } return obj; ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) } type A = { a: string }; ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->a : Symbol(a, Decl(mappedTypes4.ts, 19, 10)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>a : Symbol(a, Decl(mappedTypes4.ts, 18, 10)) type B = { b: string }; ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->b : Symbol(b, Decl(mappedTypes4.ts, 20, 10)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>b : Symbol(b, Decl(mappedTypes4.ts, 19, 10)) type C = { c: string }; ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) ->c : Symbol(c, Decl(mappedTypes4.ts, 21, 10)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) +>c : Symbol(c, Decl(mappedTypes4.ts, 20, 10)) function f1(x: A | B | C | undefined) { ->f1 : Symbol(f1, Decl(mappedTypes4.ts, 21, 23)) ->x : Symbol(x, Decl(mappedTypes4.ts, 23, 12)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>f1 : Symbol(f1, Decl(mappedTypes4.ts, 20, 23)) +>x : Symbol(x, Decl(mappedTypes4.ts, 22, 12)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) return boxify(x); ->boxify : Symbol(boxify, Decl(mappedTypes4.ts, 6, 2)) ->x : Symbol(x, Decl(mappedTypes4.ts, 23, 12)) +>boxify : Symbol(boxify, Decl(mappedTypes4.ts, 5, 2)) +>x : Symbol(x, Decl(mappedTypes4.ts, 22, 12)) } type T00 = Partial; ->T00 : Symbol(T00, Decl(mappedTypes4.ts, 25, 1)) +>T00 : Symbol(T00, Decl(mappedTypes4.ts, 24, 1)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T01 = Readonly; ->T01 : Symbol(T01, Decl(mappedTypes4.ts, 27, 30)) +>T01 : Symbol(T01, Decl(mappedTypes4.ts, 26, 30)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T02 = Boxified ->T02 : Symbol(T02, Decl(mappedTypes4.ts, 28, 50)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>T02 : Symbol(T02, Decl(mappedTypes4.ts, 27, 50)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T03 = Readonly; ->T03 : Symbol(T03, Decl(mappedTypes4.ts, 29, 41)) +>T03 : Symbol(T03, Decl(mappedTypes4.ts, 28, 41)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) type T04 = Boxified; ->T04 : Symbol(T04, Decl(mappedTypes4.ts, 30, 73)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) +>T04 : Symbol(T04, Decl(mappedTypes4.ts, 29, 73)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) type T05 = Partial<"hello" | "world" | 42>; ->T05 : Symbol(T05, Decl(mappedTypes4.ts, 31, 73)) +>T05 : Symbol(T05, Decl(mappedTypes4.ts, 30, 73)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) type BoxifiedWithSentinel = { ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) ->T : Symbol(T, Decl(mappedTypes4.ts, 34, 26)) ->U : Symbol(U, Decl(mappedTypes4.ts, 34, 28)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) +>T : Symbol(T, Decl(mappedTypes4.ts, 33, 26)) +>U : Symbol(U, Decl(mappedTypes4.ts, 33, 28)) [P in keyof T]: Box | U; ->P : Symbol(P, Decl(mappedTypes4.ts, 35, 5)) ->T : Symbol(T, Decl(mappedTypes4.ts, 34, 26)) +>P : Symbol(P, Decl(mappedTypes4.ts, 34, 5)) +>T : Symbol(T, Decl(mappedTypes4.ts, 33, 26)) >Box : Symbol(Box, Decl(mappedTypes4.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes4.ts, 34, 26)) ->P : Symbol(P, Decl(mappedTypes4.ts, 35, 5)) ->U : Symbol(U, Decl(mappedTypes4.ts, 34, 28)) +>T : Symbol(T, Decl(mappedTypes4.ts, 33, 26)) +>P : Symbol(P, Decl(mappedTypes4.ts, 34, 5)) +>U : Symbol(U, Decl(mappedTypes4.ts, 33, 28)) } type T10 = BoxifiedWithSentinel; ->T10 : Symbol(T10, Decl(mappedTypes4.ts, 36, 1)) ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>T10 : Symbol(T10, Decl(mappedTypes4.ts, 35, 1)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T11 = BoxifiedWithSentinel; ->T11 : Symbol(T11, Decl(mappedTypes4.ts, 38, 49)) ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>T11 : Symbol(T11, Decl(mappedTypes4.ts, 37, 49)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T12 = BoxifiedWithSentinel; ->T12 : Symbol(T12, Decl(mappedTypes4.ts, 39, 54)) ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) +>T12 : Symbol(T12, Decl(mappedTypes4.ts, 38, 54)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) type DeepReadonly = { ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 40, 51)) ->T : Symbol(T, Decl(mappedTypes4.ts, 42, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 39, 51)) +>T : Symbol(T, Decl(mappedTypes4.ts, 41, 18)) readonly [P in keyof T]: DeepReadonly; ->P : Symbol(P, Decl(mappedTypes4.ts, 43, 14)) ->T : Symbol(T, Decl(mappedTypes4.ts, 42, 18)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 40, 51)) ->T : Symbol(T, Decl(mappedTypes4.ts, 42, 18)) ->P : Symbol(P, Decl(mappedTypes4.ts, 43, 14)) +>P : Symbol(P, Decl(mappedTypes4.ts, 42, 14)) +>T : Symbol(T, Decl(mappedTypes4.ts, 41, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 39, 51)) +>T : Symbol(T, Decl(mappedTypes4.ts, 41, 18)) +>P : Symbol(P, Decl(mappedTypes4.ts, 42, 14)) }; type Foo = { ->Foo : Symbol(Foo, Decl(mappedTypes4.ts, 44, 2)) +>Foo : Symbol(Foo, Decl(mappedTypes4.ts, 43, 2)) x: number; ->x : Symbol(x, Decl(mappedTypes4.ts, 46, 12)) +>x : Symbol(x, Decl(mappedTypes4.ts, 45, 12)) y: { a: string, b: number }; ->y : Symbol(y, Decl(mappedTypes4.ts, 47, 14)) ->a : Symbol(a, Decl(mappedTypes4.ts, 48, 8)) ->b : Symbol(b, Decl(mappedTypes4.ts, 48, 19)) +>y : Symbol(y, Decl(mappedTypes4.ts, 46, 14)) +>a : Symbol(a, Decl(mappedTypes4.ts, 47, 8)) +>b : Symbol(b, Decl(mappedTypes4.ts, 47, 19)) z: boolean; ->z : Symbol(z, Decl(mappedTypes4.ts, 48, 32)) +>z : Symbol(z, Decl(mappedTypes4.ts, 47, 32)) }; type DeepReadonlyFoo = { ->DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 50, 2)) +>DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 49, 2)) readonly x: number; ->x : Symbol(x, Decl(mappedTypes4.ts, 52, 24)) +>x : Symbol(x, Decl(mappedTypes4.ts, 51, 24)) readonly y: { readonly a: string, readonly b: number }; ->y : Symbol(y, Decl(mappedTypes4.ts, 53, 23)) ->a : Symbol(a, Decl(mappedTypes4.ts, 54, 17)) ->b : Symbol(b, Decl(mappedTypes4.ts, 54, 37)) +>y : Symbol(y, Decl(mappedTypes4.ts, 52, 23)) +>a : Symbol(a, Decl(mappedTypes4.ts, 53, 17)) +>b : Symbol(b, Decl(mappedTypes4.ts, 53, 37)) readonly z: boolean; ->z : Symbol(z, Decl(mappedTypes4.ts, 54, 59)) +>z : Symbol(z, Decl(mappedTypes4.ts, 53, 59)) }; var x1: DeepReadonly; ->x1 : Symbol(x1, Decl(mappedTypes4.ts, 58, 3), Decl(mappedTypes4.ts, 59, 3)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 40, 51)) ->Foo : Symbol(Foo, Decl(mappedTypes4.ts, 44, 2)) +>x1 : Symbol(x1, Decl(mappedTypes4.ts, 57, 3), Decl(mappedTypes4.ts, 58, 3)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 39, 51)) +>Foo : Symbol(Foo, Decl(mappedTypes4.ts, 43, 2)) var x1: DeepReadonlyFoo; ->x1 : Symbol(x1, Decl(mappedTypes4.ts, 58, 3), Decl(mappedTypes4.ts, 59, 3)) ->DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 50, 2)) +>x1 : Symbol(x1, Decl(mappedTypes4.ts, 57, 3), Decl(mappedTypes4.ts, 58, 3)) +>DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 49, 2)) // Repro from #13232 type Z = { a: number }; ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) ->a : Symbol(a, Decl(mappedTypes4.ts, 63, 10)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) +>a : Symbol(a, Decl(mappedTypes4.ts, 62, 10)) type Clone = { ->Clone : Symbol(Clone, Decl(mappedTypes4.ts, 63, 23)) ->T : Symbol(T, Decl(mappedTypes4.ts, 64, 11)) +>Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23)) +>T : Symbol(T, Decl(mappedTypes4.ts, 63, 11)) [P in keyof (T & {})]: T[P]; ->P : Symbol(P, Decl(mappedTypes4.ts, 65, 3)) ->T : Symbol(T, Decl(mappedTypes4.ts, 64, 11)) ->T : Symbol(T, Decl(mappedTypes4.ts, 64, 11)) ->P : Symbol(P, Decl(mappedTypes4.ts, 65, 3)) +>P : Symbol(P, Decl(mappedTypes4.ts, 64, 3)) +>T : Symbol(T, Decl(mappedTypes4.ts, 63, 11)) +>T : Symbol(T, Decl(mappedTypes4.ts, 63, 11)) +>P : Symbol(P, Decl(mappedTypes4.ts, 64, 3)) }; type M = Clone; // M should be { a: number } ->M : Symbol(M, Decl(mappedTypes4.ts, 66, 2)) ->Clone : Symbol(Clone, Decl(mappedTypes4.ts, 63, 23)) ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) +>M : Symbol(M, Decl(mappedTypes4.ts, 65, 2)) +>Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) var z1: Z; ->z1 : Symbol(z1, Decl(mappedTypes4.ts, 69, 3), Decl(mappedTypes4.ts, 70, 3)) ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) +>z1 : Symbol(z1, Decl(mappedTypes4.ts, 68, 3), Decl(mappedTypes4.ts, 69, 3)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) var z1: Clone; ->z1 : Symbol(z1, Decl(mappedTypes4.ts, 69, 3), Decl(mappedTypes4.ts, 70, 3)) ->Clone : Symbol(Clone, Decl(mappedTypes4.ts, 63, 23)) ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) +>z1 : Symbol(z1, Decl(mappedTypes4.ts, 68, 3), Decl(mappedTypes4.ts, 69, 3)) +>Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) diff --git a/tests/baselines/reference/mappedTypes4.types b/tests/baselines/reference/mappedTypes4.types index 1d0c4c16b89..30e7eb2431b 100644 --- a/tests/baselines/reference/mappedTypes4.types +++ b/tests/baselines/reference/mappedTypes4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes4.ts === - type Box = { >Box : Box >T : T diff --git a/tests/baselines/reference/mappedTypesAndObjects.js b/tests/baselines/reference/mappedTypesAndObjects.js index f320cc9624e..664f3b9572d 100644 --- a/tests/baselines/reference/mappedTypesAndObjects.js +++ b/tests/baselines/reference/mappedTypesAndObjects.js @@ -1,5 +1,4 @@ //// [mappedTypesAndObjects.ts] - function f1(x: Partial, y: Readonly) { let obj: {}; obj = x; diff --git a/tests/baselines/reference/mappedTypesAndObjects.symbols b/tests/baselines/reference/mappedTypesAndObjects.symbols index 6fb5d720fb3..2bbab833343 100644 --- a/tests/baselines/reference/mappedTypesAndObjects.symbols +++ b/tests/baselines/reference/mappedTypesAndObjects.symbols @@ -1,124 +1,123 @@ === tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts === - function f1(x: Partial, y: Readonly) { >f1 : Symbol(f1, Decl(mappedTypesAndObjects.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 1, 12)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 1, 15)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 0, 12)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 0, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 1, 12)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 1, 29)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 0, 12)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 0, 29)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 1, 12)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 0, 12)) let obj: {}; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 2, 7)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 1, 7)) obj = x; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 2, 7)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 1, 15)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 1, 7)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 0, 15)) obj = y; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 2, 7)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 1, 29)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 1, 7)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 0, 29)) } function f2(x: Partial, y: Readonly) { ->f2 : Symbol(f2, Decl(mappedTypesAndObjects.ts, 5, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 7, 12)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 7, 15)) +>f2 : Symbol(f2, Decl(mappedTypesAndObjects.ts, 4, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 6, 12)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 6, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 7, 12)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 7, 29)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 6, 12)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 6, 29)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 7, 12)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 6, 12)) let obj: { [x: string]: any }; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 8, 7)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 8, 16)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 7, 7)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 7, 16)) obj = x; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 8, 7)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 7, 15)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 7, 7)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 6, 15)) obj = y; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 8, 7)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 7, 29)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 7, 7)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 6, 29)) } function f3(x: Partial) { ->f3 : Symbol(f3, Decl(mappedTypesAndObjects.ts, 11, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 13, 12)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 13, 15)) +>f3 : Symbol(f3, Decl(mappedTypesAndObjects.ts, 10, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 12, 12)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 12, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 13, 12)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 12, 12)) x = {}; ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 13, 15)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 12, 15)) } // Repro from #12900 interface Base { ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: { [key: string]: any }; ->foo : Symbol(Base.foo, Decl(mappedTypesAndObjects.ts, 19, 16)) ->key : Symbol(key, Decl(mappedTypesAndObjects.ts, 20, 12)) +>foo : Symbol(Base.foo, Decl(mappedTypesAndObjects.ts, 18, 16)) +>key : Symbol(key, Decl(mappedTypesAndObjects.ts, 19, 12)) bar: any; ->bar : Symbol(Base.bar, Decl(mappedTypesAndObjects.ts, 20, 32)) +>bar : Symbol(Base.bar, Decl(mappedTypesAndObjects.ts, 19, 32)) baz: any; ->baz : Symbol(Base.baz, Decl(mappedTypesAndObjects.ts, 21, 13)) +>baz : Symbol(Base.baz, Decl(mappedTypesAndObjects.ts, 20, 13)) } interface E1 extends Base { ->E1 : Symbol(E1, Decl(mappedTypesAndObjects.ts, 23, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 25, 13)) ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>E1 : Symbol(E1, Decl(mappedTypesAndObjects.ts, 22, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 24, 13)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: T; ->foo : Symbol(E1.foo, Decl(mappedTypesAndObjects.ts, 25, 30)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 25, 13)) +>foo : Symbol(E1.foo, Decl(mappedTypesAndObjects.ts, 24, 30)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 24, 13)) } interface Something { name: string, value: string }; ->Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 27, 1)) ->name : Symbol(Something.name, Decl(mappedTypesAndObjects.ts, 29, 21)) ->value : Symbol(Something.value, Decl(mappedTypesAndObjects.ts, 29, 35)) +>Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 26, 1)) +>name : Symbol(Something.name, Decl(mappedTypesAndObjects.ts, 28, 21)) +>value : Symbol(Something.value, Decl(mappedTypesAndObjects.ts, 28, 35)) interface E2 extends Base { ->E2 : Symbol(E2, Decl(mappedTypesAndObjects.ts, 29, 52)) ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>E2 : Symbol(E2, Decl(mappedTypesAndObjects.ts, 28, 52)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: Partial; // or other mapped type ->foo : Symbol(E2.foo, Decl(mappedTypesAndObjects.ts, 30, 27)) +>foo : Symbol(E2.foo, Decl(mappedTypesAndObjects.ts, 29, 27)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 27, 1)) +>Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 26, 1)) } interface E3 extends Base { ->E3 : Symbol(E3, Decl(mappedTypesAndObjects.ts, 32, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 34, 13)) ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>E3 : Symbol(E3, Decl(mappedTypesAndObjects.ts, 31, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 33, 13)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: Partial; // or other mapped type ->foo : Symbol(E3.foo, Decl(mappedTypesAndObjects.ts, 34, 30)) +>foo : Symbol(E3.foo, Decl(mappedTypesAndObjects.ts, 33, 30)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 34, 13)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 33, 13)) } // Repro from #13747 class Form { ->Form : Symbol(Form, Decl(mappedTypesAndObjects.ts, 36, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11)) +>Form : Symbol(Form, Decl(mappedTypesAndObjects.ts, 35, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 39, 11)) private values: {[P in keyof T]?: T[P]} = {} ->values : Symbol(Form.values, Decl(mappedTypesAndObjects.ts, 40, 15)) ->P : Symbol(P, Decl(mappedTypesAndObjects.ts, 41, 22)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11)) ->P : Symbol(P, Decl(mappedTypesAndObjects.ts, 41, 22)) +>values : Symbol(Form.values, Decl(mappedTypesAndObjects.ts, 39, 15)) +>P : Symbol(P, Decl(mappedTypesAndObjects.ts, 40, 22)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 39, 11)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 39, 11)) +>P : Symbol(P, Decl(mappedTypesAndObjects.ts, 40, 22)) } diff --git a/tests/baselines/reference/mappedTypesAndObjects.types b/tests/baselines/reference/mappedTypesAndObjects.types index 75f71082f31..78acf606396 100644 --- a/tests/baselines/reference/mappedTypesAndObjects.types +++ b/tests/baselines/reference/mappedTypesAndObjects.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts === - function f1(x: Partial, y: Readonly) { >f1 : (x: Partial, y: Readonly) => void >T : T diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.js b/tests/baselines/reference/mergeClassInterfaceAndModule.js index 5b7315031cd..132a1947808 100644 --- a/tests/baselines/reference/mergeClassInterfaceAndModule.js +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.js @@ -1,5 +1,4 @@ //// [mergeClassInterfaceAndModule.ts] - interface C1 {} declare class C1 {} module C1 {} diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.symbols b/tests/baselines/reference/mergeClassInterfaceAndModule.symbols index a10227ed461..eae65b622f7 100644 --- a/tests/baselines/reference/mergeClassInterfaceAndModule.symbols +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.symbols @@ -1,38 +1,37 @@ === tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts === - interface C1 {} ->C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 0, 15), Decl(mergeClassInterfaceAndModule.ts, 1, 19)) declare class C1 {} ->C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 0, 15), Decl(mergeClassInterfaceAndModule.ts, 1, 19)) module C1 {} ->C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 0, 15), Decl(mergeClassInterfaceAndModule.ts, 1, 19)) declare class C2 {} ->C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 2, 12), Decl(mergeClassInterfaceAndModule.ts, 4, 19), Decl(mergeClassInterfaceAndModule.ts, 5, 15)) interface C2 {} ->C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 2, 12), Decl(mergeClassInterfaceAndModule.ts, 4, 19), Decl(mergeClassInterfaceAndModule.ts, 5, 15)) module C2 {} ->C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 2, 12), Decl(mergeClassInterfaceAndModule.ts, 4, 19), Decl(mergeClassInterfaceAndModule.ts, 5, 15)) declare class C3 {} ->C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 6, 12), Decl(mergeClassInterfaceAndModule.ts, 8, 19), Decl(mergeClassInterfaceAndModule.ts, 9, 12)) module C3 {} ->C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 6, 12), Decl(mergeClassInterfaceAndModule.ts, 8, 19), Decl(mergeClassInterfaceAndModule.ts, 9, 12)) interface C3 {} ->C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 6, 12), Decl(mergeClassInterfaceAndModule.ts, 8, 19), Decl(mergeClassInterfaceAndModule.ts, 9, 12)) module C4 {} ->C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 10, 15), Decl(mergeClassInterfaceAndModule.ts, 12, 12), Decl(mergeClassInterfaceAndModule.ts, 13, 19)) declare class C4 {} // error -- class declaration must preceed module declaration ->C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 10, 15), Decl(mergeClassInterfaceAndModule.ts, 12, 12), Decl(mergeClassInterfaceAndModule.ts, 13, 19)) interface C4 {} ->C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 10, 15), Decl(mergeClassInterfaceAndModule.ts, 12, 12), Decl(mergeClassInterfaceAndModule.ts, 13, 19)) diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.types b/tests/baselines/reference/mergeClassInterfaceAndModule.types index a91691e5bac..9bb1ebeba70 100644 --- a/tests/baselines/reference/mergeClassInterfaceAndModule.types +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts === - interface C1 {} >C1 : C1 diff --git a/tests/baselines/reference/mergedClassInterface.js b/tests/baselines/reference/mergedClassInterface.js index 913c0472cbd..54f806f2017 100644 --- a/tests/baselines/reference/mergedClassInterface.js +++ b/tests/baselines/reference/mergedClassInterface.js @@ -1,8 +1,6 @@ //// [tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts] //// //// [file1.ts] - - declare class C1 { } interface C1 { } @@ -43,13 +41,11 @@ c5.x3; c5.x4; //// [file2.ts] - declare class C6 { } interface C7 { } //// [file3.ts] - interface C6 { } declare class C7 { } diff --git a/tests/baselines/reference/mergedClassInterface.symbols b/tests/baselines/reference/mergedClassInterface.symbols index 8de9a9557c1..d37dc46cb52 100644 --- a/tests/baselines/reference/mergedClassInterface.symbols +++ b/tests/baselines/reference/mergedClassInterface.symbols @@ -1,96 +1,92 @@ === tests/cases/conformance/classes/classDeclarations/file1.ts === - - declare class C1 { } ->C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 2, 20)) +>C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 20)) interface C1 { } ->C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 2, 20)) +>C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 20)) interface C2 { } ->C2 : Symbol(C2, Decl(file1.ts, 4, 16), Decl(file1.ts, 6, 16)) +>C2 : Symbol(C2, Decl(file1.ts, 2, 16), Decl(file1.ts, 4, 16)) declare class C2 { } ->C2 : Symbol(C2, Decl(file1.ts, 4, 16), Decl(file1.ts, 6, 16)) +>C2 : Symbol(C2, Decl(file1.ts, 2, 16), Decl(file1.ts, 4, 16)) class C3 { } ->C3 : Symbol(C3, Decl(file1.ts, 8, 20), Decl(file1.ts, 10, 12)) +>C3 : Symbol(C3, Decl(file1.ts, 6, 20), Decl(file1.ts, 8, 12)) interface C3 { } ->C3 : Symbol(C3, Decl(file1.ts, 8, 20), Decl(file1.ts, 10, 12)) +>C3 : Symbol(C3, Decl(file1.ts, 6, 20), Decl(file1.ts, 8, 12)) interface C4 { } ->C4 : Symbol(C4, Decl(file1.ts, 12, 16), Decl(file1.ts, 14, 16)) +>C4 : Symbol(C4, Decl(file1.ts, 10, 16), Decl(file1.ts, 12, 16)) class C4 { } ->C4 : Symbol(C4, Decl(file1.ts, 12, 16), Decl(file1.ts, 14, 16)) +>C4 : Symbol(C4, Decl(file1.ts, 10, 16), Decl(file1.ts, 12, 16)) interface C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x1: number; ->x1 : Symbol(C5.x1, Decl(file1.ts, 18, 14)) +>x1 : Symbol(C5.x1, Decl(file1.ts, 16, 14)) } declare class C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x2: number; ->x2 : Symbol(C5.x2, Decl(file1.ts, 22, 18)) +>x2 : Symbol(C5.x2, Decl(file1.ts, 20, 18)) } interface C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x3: number; ->x3 : Symbol(C5.x3, Decl(file1.ts, 26, 14)) +>x3 : Symbol(C5.x3, Decl(file1.ts, 24, 14)) } interface C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x4: number; ->x4 : Symbol(C5.x4, Decl(file1.ts, 30, 14)) +>x4 : Symbol(C5.x4, Decl(file1.ts, 28, 14)) } // checks if properties actually were merged var c5 : C5; ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) c5.x1; ->c5.x1 : Symbol(C5.x1, Decl(file1.ts, 18, 14)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x1 : Symbol(C5.x1, Decl(file1.ts, 18, 14)) +>c5.x1 : Symbol(C5.x1, Decl(file1.ts, 16, 14)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x1 : Symbol(C5.x1, Decl(file1.ts, 16, 14)) c5.x2; ->c5.x2 : Symbol(C5.x2, Decl(file1.ts, 22, 18)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x2 : Symbol(C5.x2, Decl(file1.ts, 22, 18)) +>c5.x2 : Symbol(C5.x2, Decl(file1.ts, 20, 18)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x2 : Symbol(C5.x2, Decl(file1.ts, 20, 18)) c5.x3; ->c5.x3 : Symbol(C5.x3, Decl(file1.ts, 26, 14)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x3 : Symbol(C5.x3, Decl(file1.ts, 26, 14)) +>c5.x3 : Symbol(C5.x3, Decl(file1.ts, 24, 14)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x3 : Symbol(C5.x3, Decl(file1.ts, 24, 14)) c5.x4; ->c5.x4 : Symbol(C5.x4, Decl(file1.ts, 30, 14)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x4 : Symbol(C5.x4, Decl(file1.ts, 30, 14)) +>c5.x4 : Symbol(C5.x4, Decl(file1.ts, 28, 14)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x4 : Symbol(C5.x4, Decl(file1.ts, 28, 14)) === tests/cases/conformance/classes/classDeclarations/file2.ts === - declare class C6 { } >C6 : Symbol(C6, Decl(file2.ts, 0, 0), Decl(file3.ts, 0, 0)) interface C7 { } ->C7 : Symbol(C7, Decl(file2.ts, 1, 20), Decl(file3.ts, 1, 16)) +>C7 : Symbol(C7, Decl(file2.ts, 0, 20), Decl(file3.ts, 0, 16)) === tests/cases/conformance/classes/classDeclarations/file3.ts === - interface C6 { } >C6 : Symbol(C6, Decl(file2.ts, 0, 0), Decl(file3.ts, 0, 0)) declare class C7 { } ->C7 : Symbol(C7, Decl(file2.ts, 1, 20), Decl(file3.ts, 1, 16)) +>C7 : Symbol(C7, Decl(file2.ts, 0, 20), Decl(file3.ts, 0, 16)) diff --git a/tests/baselines/reference/mergedClassInterface.types b/tests/baselines/reference/mergedClassInterface.types index 4c3a6cca6a9..b58f26d0112 100644 --- a/tests/baselines/reference/mergedClassInterface.types +++ b/tests/baselines/reference/mergedClassInterface.types @@ -1,6 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/file1.ts === - - declare class C1 { } >C1 : C1 @@ -79,7 +77,6 @@ c5.x4; >x4 : number === tests/cases/conformance/classes/classDeclarations/file2.ts === - declare class C6 { } >C6 : C6 @@ -87,7 +84,6 @@ interface C7 { } >C7 : C7 === tests/cases/conformance/classes/classDeclarations/file3.ts === - interface C6 { } >C6 : C6 diff --git a/tests/baselines/reference/mergedDeclarations6.js b/tests/baselines/reference/mergedDeclarations6.js index 83173f35752..2b492b569c2 100644 --- a/tests/baselines/reference/mergedDeclarations6.js +++ b/tests/baselines/reference/mergedDeclarations6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/mergedDeclarations6.ts] //// //// [a.ts] - export class A { protected protected: any; diff --git a/tests/baselines/reference/mergedDeclarations6.symbols b/tests/baselines/reference/mergedDeclarations6.symbols index a51dcf75e9c..7a10ff260a2 100644 --- a/tests/baselines/reference/mergedDeclarations6.symbols +++ b/tests/baselines/reference/mergedDeclarations6.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/a.ts === - export class A { >A : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 2, 22)) protected protected: any; ->protected : Symbol(A.protected, Decl(a.ts, 1, 16)) +>protected : Symbol(A.protected, Decl(a.ts, 0, 16)) protected setProtected(val: any) { ->setProtected : Symbol(A.setProtected, Decl(a.ts, 2, 29)) ->val : Symbol(val, Decl(a.ts, 4, 27)) +>setProtected : Symbol(A.setProtected, Decl(a.ts, 1, 29)) +>val : Symbol(val, Decl(a.ts, 3, 27)) this.protected = val; ->this.protected : Symbol(A.protected, Decl(a.ts, 1, 16)) +>this.protected : Symbol(A.protected, Decl(a.ts, 0, 16)) >this : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 2, 22)) ->protected : Symbol(A.protected, Decl(a.ts, 1, 16)) ->val : Symbol(val, Decl(a.ts, 4, 27)) +>protected : Symbol(A.protected, Decl(a.ts, 0, 16)) +>val : Symbol(val, Decl(a.ts, 3, 27)) } } diff --git a/tests/baselines/reference/mergedDeclarations6.types b/tests/baselines/reference/mergedDeclarations6.types index 6198c08f6b5..d6c109f6597 100644 --- a/tests/baselines/reference/mergedDeclarations6.types +++ b/tests/baselines/reference/mergedDeclarations6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A { >A : A diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js index ab1eafa1c9c..31f25d22b79 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/mergedInterfaceFromMultipleFiles1.ts] //// //// [mergedInterfaceFromMultipleFiles1_0.ts] - interface I { foo(): string; } interface C extends I { diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols index 4dffd06bcde..bb197a97aeb 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols @@ -6,7 +6,7 @@ interface D { bar(): number; } >bar : Symbol(D.bar, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 13)) interface C extends D { ->C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) +>C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) >D : Symbol(D, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 0, 0)) b(): Date; @@ -16,13 +16,13 @@ interface C extends D { var c:C; >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) ->C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) +>C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) var a: string = c.foo(); >a : Symbol(a, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 9, 3)) ->c.foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 13)) +>c.foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 13)) >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) ->foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 13)) +>foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 13)) var b: number = c.bar(); >b : Symbol(b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 10, 3)) @@ -32,9 +32,9 @@ var b: number = c.bar(); var d: number = c.a(); >d : Symbol(d, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 11, 3)) ->c.a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 3, 23)) +>c.a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 2, 23)) >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) ->a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 3, 23)) +>a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 2, 23)) var e: Date = c.b(); >e : Symbol(e, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 12, 3)) @@ -44,16 +44,15 @@ var e: Date = c.b(); >b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23)) === tests/cases/compiler/mergedInterfaceFromMultipleFiles1_0.ts === - interface I { foo(): string; } >I : Symbol(I, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 0)) ->foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 13)) +>foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 13)) interface C extends I { ->C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) +>C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) >I : Symbol(I, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 0)) a(): number; ->a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 3, 23)) +>a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 2, 23)) } diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types index ad6b07f0312..374017d45df 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types @@ -48,7 +48,6 @@ var e: Date = c.b(); >b : () => Date === tests/cases/compiler/mergedInterfaceFromMultipleFiles1_0.ts === - interface I { foo(): string; } >I : I >foo : () => string diff --git a/tests/baselines/reference/metadataOfEventAlias.js b/tests/baselines/reference/metadataOfEventAlias.js index 40cbc87cdcb..b46d5cade63 100644 --- a/tests/baselines/reference/metadataOfEventAlias.js +++ b/tests/baselines/reference/metadataOfEventAlias.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/metadataOfEventAlias.ts] //// //// [event.ts] - export interface Event { title: string }; //// [test.ts] diff --git a/tests/baselines/reference/metadataOfEventAlias.symbols b/tests/baselines/reference/metadataOfEventAlias.symbols index 441714e63e6..15f27cbca23 100644 --- a/tests/baselines/reference/metadataOfEventAlias.symbols +++ b/tests/baselines/reference/metadataOfEventAlias.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/event.ts === - export interface Event { title: string }; >Event : Symbol(Event, Decl(event.ts, 0, 0)) ->title : Symbol(Event.title, Decl(event.ts, 1, 24)) +>title : Symbol(Event.title, Decl(event.ts, 0, 24)) === tests/cases/compiler/test.ts === import { Event } from './event'; diff --git a/tests/baselines/reference/metadataOfEventAlias.types b/tests/baselines/reference/metadataOfEventAlias.types index b644552f9c2..01b97bfbac1 100644 --- a/tests/baselines/reference/metadataOfEventAlias.types +++ b/tests/baselines/reference/metadataOfEventAlias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/event.ts === - export interface Event { title: string }; >Event : Event >title : string diff --git a/tests/baselines/reference/missingDecoratorType.errors.txt b/tests/baselines/reference/missingDecoratorType.errors.txt index f2af7d49b57..b9443356306 100644 --- a/tests/baselines/reference/missingDecoratorType.errors.txt +++ b/tests/baselines/reference/missingDecoratorType.errors.txt @@ -3,7 +3,6 @@ error TS2318: Cannot find global type 'TypedPropertyDescriptor'. !!! error TS2318: Cannot find global type 'TypedPropertyDescriptor'. ==== tests/cases/conformance/decorators/a.ts (0 errors) ==== - interface Object { } interface Array { } interface String { } diff --git a/tests/baselines/reference/missingDecoratorType.js b/tests/baselines/reference/missingDecoratorType.js index 1dcbb3febc5..ee9fbf7ce44 100644 --- a/tests/baselines/reference/missingDecoratorType.js +++ b/tests/baselines/reference/missingDecoratorType.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/missingDecoratorType.ts] //// //// [a.ts] - interface Object { } interface Array { } interface String { } diff --git a/tests/baselines/reference/missingFunctionImplementation.errors.txt b/tests/baselines/reference/missingFunctionImplementation.errors.txt index 4cf58d97d49..1bb938fca07 100644 --- a/tests/baselines/reference/missingFunctionImplementation.errors.txt +++ b/tests/baselines/reference/missingFunctionImplementation.errors.txt @@ -1,26 +1,25 @@ -tests/cases/compiler/missingFunctionImplementation.ts(3,3): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(8,3): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(16,3): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(22,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(28,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(33,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(41,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(2,3): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(7,3): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(15,3): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(21,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(27,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(32,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(40,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(47,10): error TS2300: Duplicate identifier 'm'. tests/cases/compiler/missingFunctionImplementation.ts(48,10): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(49,10): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(49,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(52,19): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(57,10): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(60,19): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(60,19): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(65,19): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(48,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(51,19): error TS2300: Duplicate identifier 'm'. +tests/cases/compiler/missingFunctionImplementation.ts(56,10): error TS2300: Duplicate identifier 'm'. +tests/cases/compiler/missingFunctionImplementation.ts(59,19): error TS2300: Duplicate identifier 'm'. +tests/cases/compiler/missingFunctionImplementation.ts(59,19): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(64,19): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(72,19): error TS2393: Duplicate function implementation. tests/cases/compiler/missingFunctionImplementation.ts(73,19): error TS2393: Duplicate function implementation. tests/cases/compiler/missingFunctionImplementation.ts(74,19): error TS2393: Duplicate function implementation. -tests/cases/compiler/missingFunctionImplementation.ts(75,19): error TS2393: Duplicate function implementation. -tests/cases/compiler/missingFunctionImplementation.ts(78,19): error TS2393: Duplicate function implementation. +tests/cases/compiler/missingFunctionImplementation.ts(77,19): error TS2393: Duplicate function implementation. ==== tests/cases/compiler/missingFunctionImplementation.ts (19 errors) ==== - export class C1 { m(): void; ~ diff --git a/tests/baselines/reference/missingFunctionImplementation.js b/tests/baselines/reference/missingFunctionImplementation.js index 23bb2356640..5ca505dff85 100644 --- a/tests/baselines/reference/missingFunctionImplementation.js +++ b/tests/baselines/reference/missingFunctionImplementation.js @@ -1,5 +1,4 @@ //// [missingFunctionImplementation.ts] - export class C1 { m(): void; } diff --git a/tests/baselines/reference/missingImportAfterModuleImport.js b/tests/baselines/reference/missingImportAfterModuleImport.js index 2739ced1cdd..7d63c07b822 100644 --- a/tests/baselines/reference/missingImportAfterModuleImport.js +++ b/tests/baselines/reference/missingImportAfterModuleImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/missingImportAfterModuleImport.ts] //// //// [missingImportAfterModuleImport_0.ts] - declare module "SubModule" { class SubModule { public static StaticVar: number; diff --git a/tests/baselines/reference/missingImportAfterModuleImport.symbols b/tests/baselines/reference/missingImportAfterModuleImport.symbols index 5493d58c528..1b8de78e41b 100644 --- a/tests/baselines/reference/missingImportAfterModuleImport.symbols +++ b/tests/baselines/reference/missingImportAfterModuleImport.symbols @@ -18,20 +18,19 @@ export = MainModule; === tests/cases/compiler/missingImportAfterModuleImport_0.ts === - declare module "SubModule" { class SubModule { ->SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 1, 28)) +>SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 0, 28)) public static StaticVar: number; ->StaticVar : Symbol(SubModule.StaticVar, Decl(missingImportAfterModuleImport_0.ts, 2, 21)) +>StaticVar : Symbol(SubModule.StaticVar, Decl(missingImportAfterModuleImport_0.ts, 1, 21)) public InstanceVar: number; ->InstanceVar : Symbol(SubModule.InstanceVar, Decl(missingImportAfterModuleImport_0.ts, 3, 40)) +>InstanceVar : Symbol(SubModule.InstanceVar, Decl(missingImportAfterModuleImport_0.ts, 2, 40)) constructor(); } export = SubModule; ->SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 1, 28)) +>SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 0, 28)) } diff --git a/tests/baselines/reference/missingImportAfterModuleImport.types b/tests/baselines/reference/missingImportAfterModuleImport.types index b8602ca06d0..41cdc9195d4 100644 --- a/tests/baselines/reference/missingImportAfterModuleImport.types +++ b/tests/baselines/reference/missingImportAfterModuleImport.types @@ -18,7 +18,6 @@ export = MainModule; === tests/cases/compiler/missingImportAfterModuleImport_0.ts === - declare module "SubModule" { class SubModule { >SubModule : SubModule diff --git a/tests/baselines/reference/missingSemicolonInModuleSpecifier.js b/tests/baselines/reference/missingSemicolonInModuleSpecifier.js index d4a8b12d2a6..889f2b800be 100644 --- a/tests/baselines/reference/missingSemicolonInModuleSpecifier.js +++ b/tests/baselines/reference/missingSemicolonInModuleSpecifier.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/missingSemicolonInModuleSpecifier.ts] //// //// [a.ts] - export const x = 1; //// [b.ts] diff --git a/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols b/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols index 695779002ac..bd0d6c4c9aa 100644 --- a/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols +++ b/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/a.ts === - export const x = 1; ->x : Symbol(x, Decl(a.ts, 1, 12)) +>x : Symbol(x, Decl(a.ts, 0, 12)) === tests/cases/compiler/b.ts === import {x} from "./a" diff --git a/tests/baselines/reference/missingSemicolonInModuleSpecifier.types b/tests/baselines/reference/missingSemicolonInModuleSpecifier.types index f7730558b68..96e043e047f 100644 --- a/tests/baselines/reference/missingSemicolonInModuleSpecifier.types +++ b/tests/baselines/reference/missingSemicolonInModuleSpecifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export const x = 1; >x : 1 >1 : 1 diff --git a/tests/baselines/reference/misspelledJsDocTypedefTags.symbols b/tests/baselines/reference/misspelledJsDocTypedefTags.symbols index bf3f6e7fab0..a0737349466 100644 --- a/tests/baselines/reference/misspelledJsDocTypedefTags.symbols +++ b/tests/baselines/reference/misspelledJsDocTypedefTags.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/a.js === - -No type information for this code./** @typedef {{ endTime: number, screenshots: number}} A.*/ +/** @typedef {{ endTime: number, screenshots: number}} A.*/ No type information for this code.Animation.AnimationModel.ScreenshotCapture.Request; No type information for this code. No type information for this code./** @typedef {{ endTime: number, screenshots: !B.}} */ diff --git a/tests/baselines/reference/misspelledJsDocTypedefTags.types b/tests/baselines/reference/misspelledJsDocTypedefTags.types index 70cc011ea69..4c483029e6c 100644 --- a/tests/baselines/reference/misspelledJsDocTypedefTags.types +++ b/tests/baselines/reference/misspelledJsDocTypedefTags.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - /** @typedef {{ endTime: number, screenshots: number}} A.*/ Animation.AnimationModel.ScreenshotCapture.Request; >Animation.AnimationModel.ScreenshotCapture.Request : any diff --git a/tests/baselines/reference/mixinAccessModifiers.errors.txt b/tests/baselines/reference/mixinAccessModifiers.errors.txt index be82571e02b..a93725e01d2 100644 --- a/tests/baselines/reference/mixinAccessModifiers.errors.txt +++ b/tests/baselines/reference/mixinAccessModifiers.errors.txt @@ -1,30 +1,29 @@ -tests/cases/conformance/classes/mixinAccessModifiers.ts(39,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Private2'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(43,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Protected'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(47,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Public'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(51,4): error TS2445: Property 'p' is protected and only accessible within class 'Protected & Protected2' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS2415: Class 'C1' incorrectly extends base class 'Private & Private2'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(38,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Private2'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(42,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Protected'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(46,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Public'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(50,4): error TS2445: Property 'p' is protected and only accessible within class 'Protected & Protected2' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(65,7): error TS2415: Class 'C1' incorrectly extends base class 'Private & Private2'. Type 'C1' is not assignable to type 'Private'. Property 'p' has conflicting declarations and is inaccessible in type 'C1'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS4093: 'extends' clause of exported class 'C1' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS2415: Class 'C2' incorrectly extends base class 'Private & Protected'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(65,7): error TS4093: 'extends' clause of exported class 'C1' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS2415: Class 'C2' incorrectly extends base class 'Private & Protected'. Type 'C2' is not assignable to type 'Private'. Property 'p' has conflicting declarations and is inaccessible in type 'C2'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(68,7): error TS2415: Class 'C3' incorrectly extends base class 'Private & Public'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS2415: Class 'C3' incorrectly extends base class 'Private & Public'. Type 'C3' is not assignable to type 'Private'. Property 'p' has conflicting declarations and is inaccessible in type 'C3'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(68,7): error TS4093: 'extends' clause of exported class 'C3' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(70,7): error TS4093: 'extends' clause of exported class 'C4' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(83,7): error TS4093: 'extends' clause of exported class 'C5' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(85,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(90,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(96,7): error TS4093: 'extends' clause of exported class 'C6' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(98,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(103,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS4093: 'extends' clause of exported class 'C3' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(69,7): error TS4093: 'extends' clause of exported class 'C4' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(82,7): error TS4093: 'extends' clause of exported class 'C5' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(84,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(89,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(95,7): error TS4093: 'extends' clause of exported class 'C6' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(97,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(102,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. ==== tests/cases/conformance/classes/mixinAccessModifiers.ts (17 errors) ==== - type Constructable = new (...args: any[]) => object; class Private { diff --git a/tests/baselines/reference/mixinAccessModifiers.js b/tests/baselines/reference/mixinAccessModifiers.js index 1db30e37a6e..8100c9db9e9 100644 --- a/tests/baselines/reference/mixinAccessModifiers.js +++ b/tests/baselines/reference/mixinAccessModifiers.js @@ -1,5 +1,4 @@ //// [mixinAccessModifiers.ts] - type Constructable = new (...args: any[]) => object; class Private { diff --git a/tests/baselines/reference/mixinClassesAnnotated.js b/tests/baselines/reference/mixinClassesAnnotated.js index e3a781033ff..15282a11dd8 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.js +++ b/tests/baselines/reference/mixinClassesAnnotated.js @@ -1,5 +1,4 @@ //// [mixinClassesAnnotated.ts] - type Constructor = new(...args: any[]) => T; class Base { diff --git a/tests/baselines/reference/mixinClassesAnnotated.symbols b/tests/baselines/reference/mixinClassesAnnotated.symbols index 5a03789e2e6..419428e6c53 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.symbols +++ b/tests/baselines/reference/mixinClassesAnnotated.symbols @@ -1,193 +1,192 @@ === tests/cases/conformance/classes/mixinClassesAnnotated.ts === - type Constructor = new(...args: any[]) => T; >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 1, 17)) ->args : Symbol(args, Decl(mixinClassesAnnotated.ts, 1, 26)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 1, 17)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 0, 17)) +>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 0, 26)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 0, 17)) class Base { ->Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) +>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) constructor(public x: number, public y: number) {} ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 3, 33)) } class Derived extends Base { ->Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1)) ->Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) +>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 4, 1)) +>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) constructor(x: number, y: number, public z: number) { ->x : Symbol(x, Decl(mixinClassesAnnotated.ts, 8, 16)) ->y : Symbol(y, Decl(mixinClassesAnnotated.ts, 8, 26)) ->z : Symbol(Derived.z, Decl(mixinClassesAnnotated.ts, 8, 37)) +>x : Symbol(x, Decl(mixinClassesAnnotated.ts, 7, 16)) +>y : Symbol(y, Decl(mixinClassesAnnotated.ts, 7, 26)) +>z : Symbol(Derived.z, Decl(mixinClassesAnnotated.ts, 7, 37)) super(x, y); ->super : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) ->x : Symbol(x, Decl(mixinClassesAnnotated.ts, 8, 16)) ->y : Symbol(y, Decl(mixinClassesAnnotated.ts, 8, 26)) +>super : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) +>x : Symbol(x, Decl(mixinClassesAnnotated.ts, 7, 16)) +>y : Symbol(y, Decl(mixinClassesAnnotated.ts, 7, 26)) } } interface Printable { ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) print(): void; ->print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) +>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) } const Printable = >(superClass: T): Constructor & { message: string } & T => ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 17, 48)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19)) +>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 16, 48)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) ->message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) +>message : Symbol(message, Decl(mixinClassesAnnotated.ts, 16, 90)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19)) class extends superClass { ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 17, 48)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 16, 48)) static message = "hello"; ->message : Symbol((Anonymous class).message, Decl(mixinClassesAnnotated.ts, 18, 30)) +>message : Symbol((Anonymous class).message, Decl(mixinClassesAnnotated.ts, 17, 30)) print() { ->print : Symbol((Anonymous class).print, Decl(mixinClassesAnnotated.ts, 19, 33)) +>print : Symbol((Anonymous class).print, Decl(mixinClassesAnnotated.ts, 18, 33)) const output = this.x + "," + this.y; ->output : Symbol(output, Decl(mixinClassesAnnotated.ts, 21, 17)) ->this.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 17, 115)) ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->this.y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33)) ->this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 17, 115)) ->y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33)) +>output : Symbol(output, Decl(mixinClassesAnnotated.ts, 20, 17)) +>this.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 16, 115)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>this.y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 3, 33)) +>this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 16, 115)) +>y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 3, 33)) } } interface Tagged { ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) _tag: string; ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) } function Tagged>(superClass: T): Constructor & T { ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 29, 43)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 28, 43)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) class C extends superClass { ->C : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84)) ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 29, 43)) +>C : Symbol(C, Decl(mixinClassesAnnotated.ts, 28, 84)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 28, 43)) _tag: string; ->_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32)) +>_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 29, 32)) constructor(...args: any[]) { ->args : Symbol(args, Decl(mixinClassesAnnotated.ts, 32, 20)) +>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 31, 20)) super(...args); ->super : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) ->args : Symbol(args, Decl(mixinClassesAnnotated.ts, 32, 20)) +>super : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) +>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 31, 20)) this._tag = "hello"; ->this._tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32)) ->this : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84)) ->_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32)) +>this._tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 29, 32)) +>this : Symbol(C, Decl(mixinClassesAnnotated.ts, 28, 84)) +>_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 29, 32)) } } return C; ->C : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84)) +>C : Symbol(C, Decl(mixinClassesAnnotated.ts, 28, 84)) } const Thing1 = Tagged(Derived); ->Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 40, 5)) ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1)) +>Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 39, 5)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 4, 1)) const Thing2 = Tagged(Printable(Derived)); ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) ->Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) +>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 4, 1)) Thing2.message; ->Thing2.message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90)) ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) ->message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90)) +>Thing2.message : Symbol(message, Decl(mixinClassesAnnotated.ts, 16, 90)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) +>message : Symbol(message, Decl(mixinClassesAnnotated.ts, 16, 90)) function f1() { ->f1 : Symbol(f1, Decl(mixinClassesAnnotated.ts, 42, 15)) +>f1 : Symbol(f1, Decl(mixinClassesAnnotated.ts, 41, 15)) const thing = new Thing1(1, 2, 3); ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9)) ->Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 40, 5)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 44, 9)) +>Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 39, 5)) thing.x; ->thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9)) ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) +>thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 44, 9)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) thing._tag; ->thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9)) ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) +>thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 44, 9)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) } function f2() { ->f2 : Symbol(f2, Decl(mixinClassesAnnotated.ts, 48, 1)) +>f2 : Symbol(f2, Decl(mixinClassesAnnotated.ts, 47, 1)) const thing = new Thing2(1, 2, 3); ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) thing.x; ->thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) +>thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) thing._tag; ->thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) +>thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) thing.print(); ->thing.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) +>thing.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) } class Thing3 extends Thing2 { ->Thing3 : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1)) ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) +>Thing3 : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 54, 1)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) constructor(tag: string) { ->tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 58, 16)) +>tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 57, 16)) super(10, 20, 30); this._tag = tag; ->this._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1)) ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 58, 16)) +>this._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 54, 1)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 57, 16)) } test() { ->test : Symbol(Thing3.test, Decl(mixinClassesAnnotated.ts, 61, 5)) +>test : Symbol(Thing3.test, Decl(mixinClassesAnnotated.ts, 60, 5)) this.print(); ->this.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) ->this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1)) ->print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) +>this.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) +>this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 54, 1)) +>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) } } diff --git a/tests/baselines/reference/mixinClassesAnnotated.types b/tests/baselines/reference/mixinClassesAnnotated.types index afaf4c4d25e..9d30171e3d8 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.types +++ b/tests/baselines/reference/mixinClassesAnnotated.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/mixinClassesAnnotated.ts === - type Constructor = new(...args: any[]) => T; >Constructor : Constructor >T : T diff --git a/tests/baselines/reference/mixinClassesMembers.js b/tests/baselines/reference/mixinClassesMembers.js index 01fc1bb0032..4771cec384d 100644 --- a/tests/baselines/reference/mixinClassesMembers.js +++ b/tests/baselines/reference/mixinClassesMembers.js @@ -1,5 +1,4 @@ //// [mixinClassesMembers.ts] - declare class C1 { public a: number; protected b: number; diff --git a/tests/baselines/reference/mixinClassesMembers.symbols b/tests/baselines/reference/mixinClassesMembers.symbols index fabfe7e6d86..35c8bb9f17f 100644 --- a/tests/baselines/reference/mixinClassesMembers.symbols +++ b/tests/baselines/reference/mixinClassesMembers.symbols @@ -1,309 +1,308 @@ === tests/cases/conformance/classes/mixinClassesMembers.ts === - declare class C1 { >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) public a: number; ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) protected b: number; ->b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) +>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) private c: number; ->c : Symbol(C1.c, Decl(mixinClassesMembers.ts, 3, 24)) +>c : Symbol(C1.c, Decl(mixinClassesMembers.ts, 2, 24)) constructor(s: string); ->s : Symbol(s, Decl(mixinClassesMembers.ts, 5, 16)) +>s : Symbol(s, Decl(mixinClassesMembers.ts, 4, 16)) constructor(n: number); ->n : Symbol(n, Decl(mixinClassesMembers.ts, 6, 16)) +>n : Symbol(n, Decl(mixinClassesMembers.ts, 5, 16)) } declare class M1 { ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) constructor(...args: any[]); ->args : Symbol(args, Decl(mixinClassesMembers.ts, 10, 16)) +>args : Symbol(args, Decl(mixinClassesMembers.ts, 9, 16)) p: number; ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) static p: number; ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) } declare class M2 { ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) constructor(...args: any[]); ->args : Symbol(args, Decl(mixinClassesMembers.ts, 16, 16)) +>args : Symbol(args, Decl(mixinClassesMembers.ts, 15, 16)) f(): number; ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) static f(): number; ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } declare const Mixed1: typeof M1 & typeof C1; ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) declare const Mixed2: typeof C1 & typeof M1; ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) declare const Mixed3: typeof M2 & typeof M1 & typeof C1; ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) declare const Mixed4: typeof C1 & typeof M1 & typeof M2; ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) declare const Mixed5: typeof M1 & typeof M2; ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) function f1() { ->f1 : Symbol(f1, Decl(mixinClassesMembers.ts, 25, 44)) +>f1 : Symbol(f1, Decl(mixinClassesMembers.ts, 24, 44)) let x1 = new Mixed1("hello"); ->x1 : Symbol(x1, Decl(mixinClassesMembers.ts, 28, 7)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>x1 : Symbol(x1, Decl(mixinClassesMembers.ts, 27, 7)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) let x2 = new Mixed1(42); ->x2 : Symbol(x2, Decl(mixinClassesMembers.ts, 29, 7)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>x2 : Symbol(x2, Decl(mixinClassesMembers.ts, 28, 7)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) let x3 = new Mixed2("hello"); ->x3 : Symbol(x3, Decl(mixinClassesMembers.ts, 30, 7)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>x3 : Symbol(x3, Decl(mixinClassesMembers.ts, 29, 7)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) let x4 = new Mixed2(42); ->x4 : Symbol(x4, Decl(mixinClassesMembers.ts, 31, 7)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>x4 : Symbol(x4, Decl(mixinClassesMembers.ts, 30, 7)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) let x5 = new Mixed3("hello"); ->x5 : Symbol(x5, Decl(mixinClassesMembers.ts, 32, 7)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>x5 : Symbol(x5, Decl(mixinClassesMembers.ts, 31, 7)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) let x6 = new Mixed3(42); ->x6 : Symbol(x6, Decl(mixinClassesMembers.ts, 33, 7)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>x6 : Symbol(x6, Decl(mixinClassesMembers.ts, 32, 7)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) let x7 = new Mixed4("hello"); ->x7 : Symbol(x7, Decl(mixinClassesMembers.ts, 34, 7)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>x7 : Symbol(x7, Decl(mixinClassesMembers.ts, 33, 7)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) let x8 = new Mixed4(42); ->x8 : Symbol(x8, Decl(mixinClassesMembers.ts, 35, 7)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>x8 : Symbol(x8, Decl(mixinClassesMembers.ts, 34, 7)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) let x9 = new Mixed5(); ->x9 : Symbol(x9, Decl(mixinClassesMembers.ts, 36, 7)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) +>x9 : Symbol(x9, Decl(mixinClassesMembers.ts, 35, 7)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) } function f2() { ->f2 : Symbol(f2, Decl(mixinClassesMembers.ts, 37, 1)) +>f2 : Symbol(f2, Decl(mixinClassesMembers.ts, 36, 1)) let x = new Mixed1("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 39, 7)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 39, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 39, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) Mixed1.p; ->Mixed1.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed1.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) } function f3() { ->f3 : Symbol(f3, Decl(mixinClassesMembers.ts, 44, 1)) +>f3 : Symbol(f3, Decl(mixinClassesMembers.ts, 43, 1)) let x = new Mixed2("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 46, 7)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 46, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 46, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) Mixed2.p; ->Mixed2.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed2.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) } function f4() { ->f4 : Symbol(f4, Decl(mixinClassesMembers.ts, 51, 1)) +>f4 : Symbol(f4, Decl(mixinClassesMembers.ts, 50, 1)) let x = new Mixed3("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) x.f(); ->x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) Mixed3.p; ->Mixed3.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed3.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) Mixed3.f(); ->Mixed3.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>Mixed3.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } function f5() { ->f5 : Symbol(f5, Decl(mixinClassesMembers.ts, 60, 1)) +>f5 : Symbol(f5, Decl(mixinClassesMembers.ts, 59, 1)) let x = new Mixed4("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) x.f(); ->x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) Mixed4.p; ->Mixed4.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed4.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) Mixed4.f(); ->Mixed4.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>Mixed4.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } function f6() { ->f6 : Symbol(f6, Decl(mixinClassesMembers.ts, 69, 1)) +>f6 : Symbol(f6, Decl(mixinClassesMembers.ts, 68, 1)) let x = new Mixed5(); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 71, 7)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 71, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) x.f(); ->x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 71, 7)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) Mixed5.p; ->Mixed5.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed5.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) Mixed5.f(); ->Mixed5.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>Mixed5.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } class C2 extends Mixed1 { ->C2 : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>C2 : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) constructor() { super("hello"); this.a; ->this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>this : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) this.b; ->this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) ->this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) +>this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) +>this : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) this.p; ->this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>this : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) } } class C3 extends Mixed3 { ->C3 : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>C3 : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) constructor() { super(42); this.a; ->this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) this.b; ->this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) +>this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) this.p; ->this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) this.f(); ->this.f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5)) +>this.f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 94, 5)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 94, 5)) } f() { return super.f(); } ->f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5)) ->super.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 94, 5)) +>super.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) } diff --git a/tests/baselines/reference/mixinClassesMembers.types b/tests/baselines/reference/mixinClassesMembers.types index c8b29175415..d53d50d34cb 100644 --- a/tests/baselines/reference/mixinClassesMembers.types +++ b/tests/baselines/reference/mixinClassesMembers.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/mixinClassesMembers.ts === - declare class C1 { >C1 : C1 diff --git a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js index f7c4db2ff2a..464e0c6f37b 100644 --- a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js +++ b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js @@ -1,5 +1,4 @@ //// [modifierOnClassDeclarationMemberInFunction.ts] - function f() { class C { public baz = 1; diff --git a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols index b41f51ffac7..757e2d165c6 100644 --- a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols +++ b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols @@ -1,18 +1,17 @@ === tests/cases/conformance/classes/classDeclarations/modifierOnClassDeclarationMemberInFunction.ts === - function f() { >f : Symbol(f, Decl(modifierOnClassDeclarationMemberInFunction.ts, 0, 0)) class C { ->C : Symbol(C, Decl(modifierOnClassDeclarationMemberInFunction.ts, 1, 14)) +>C : Symbol(C, Decl(modifierOnClassDeclarationMemberInFunction.ts, 0, 14)) public baz = 1; ->baz : Symbol(C.baz, Decl(modifierOnClassDeclarationMemberInFunction.ts, 2, 13)) +>baz : Symbol(C.baz, Decl(modifierOnClassDeclarationMemberInFunction.ts, 1, 13)) static foo() { } ->foo : Symbol(C.foo, Decl(modifierOnClassDeclarationMemberInFunction.ts, 3, 23)) +>foo : Symbol(C.foo, Decl(modifierOnClassDeclarationMemberInFunction.ts, 2, 23)) public bar() { } ->bar : Symbol(C.bar, Decl(modifierOnClassDeclarationMemberInFunction.ts, 4, 24)) +>bar : Symbol(C.bar, Decl(modifierOnClassDeclarationMemberInFunction.ts, 3, 24)) } } diff --git a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types index 097383ee75e..cb6a64b09a6 100644 --- a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types +++ b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/modifierOnClassDeclarationMemberInFunction.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js index 211c80bcce8..3403a376d42 100644 --- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js +++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js @@ -1,5 +1,4 @@ //// [modifierOnClassExpressionMemberInFunction.ts] - function g() { var x = class C { public prop1 = 1; diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols index d603d96dcda..680d9c4d78b 100644 --- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols +++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/classes/classExpressions/modifierOnClassExpressionMemberInFunction.ts === - function g() { >g : Symbol(g, Decl(modifierOnClassExpressionMemberInFunction.ts, 0, 0)) var x = class C { ->x : Symbol(x, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 7)) ->C : Symbol(C, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 11)) +>x : Symbol(x, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 7)) +>C : Symbol(C, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 11)) public prop1 = 1; ->prop1 : Symbol(C.prop1, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 21)) +>prop1 : Symbol(C.prop1, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 21)) private foo() { } ->foo : Symbol(C.foo, Decl(modifierOnClassExpressionMemberInFunction.ts, 3, 25)) +>foo : Symbol(C.foo, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 25)) static prop2 = 43; ->prop2 : Symbol(C.prop2, Decl(modifierOnClassExpressionMemberInFunction.ts, 4, 25)) +>prop2 : Symbol(C.prop2, Decl(modifierOnClassExpressionMemberInFunction.ts, 3, 25)) } } diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types index 4f454754b2b..707163e83f4 100644 --- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types +++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classExpressions/modifierOnClassExpressionMemberInFunction.ts === - function g() { >g : () => void diff --git a/tests/baselines/reference/modularizeLibrary_Dom.iterable.js b/tests/baselines/reference/modularizeLibrary_Dom.iterable.js index a448e8359a5..534173c8e5e 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.iterable.js +++ b/tests/baselines/reference/modularizeLibrary_Dom.iterable.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_Dom.iterable.ts] - for (const element of document.getElementsByTagName("a")) { element.href; } diff --git a/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols b/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols index 478997ca630..32cff5e42ad 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols +++ b/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/modularizeLibrary_Dom.iterable.ts === - for (const element of document.getElementsByTagName("a")) { ->element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 1, 10)) +>element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 0, 10)) >document.getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) >document : Symbol(document, Decl(lib.dom.d.ts, --, --)) >getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) element.href; >element.href : Symbol(HTMLAnchorElement.href, Decl(lib.dom.d.ts, --, --)) ->element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 1, 10)) +>element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 0, 10)) >href : Symbol(HTMLAnchorElement.href, Decl(lib.dom.d.ts, --, --)) } diff --git a/tests/baselines/reference/modularizeLibrary_Dom.iterable.types b/tests/baselines/reference/modularizeLibrary_Dom.iterable.types index f9a58d554cf..e8656beb985 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.iterable.types +++ b/tests/baselines/reference/modularizeLibrary_Dom.iterable.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_Dom.iterable.ts === - for (const element of document.getElementsByTagName("a")) { >element : HTMLAnchorElement >document.getElementsByTagName("a") : NodeListOf diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt index 3668e7080fd..82bc36819a5 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt @@ -1,14 +1,13 @@ error TS2318: Cannot find global type 'Boolean'. error TS2318: Cannot find global type 'IArguments'. error TS2318: Cannot find global type 'Number'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts(4,12): error TS2693: 'Array' only refers to a type, but is being used as a value here. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts(3,12): error TS2693: 'Array' only refers to a type, but is being used as a value here. !!! error TS2318: Cannot find global type 'Boolean'. !!! error TS2318: Cannot find global type 'IArguments'. !!! error TS2318: Cannot find global type 'Number'. ==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts (1 errors) ==== - // Error missing basic JavaScript objects function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js index 61591a5f7e1..9e7ecabf6f4 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts] - // Error missing basic JavaScript objects function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt index c8a69546ee0..80b8e345cde 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt @@ -1,19 +1,18 @@ -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(5,18): error TS2339: Property 'from' does not exist on type 'ArrayConstructor'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(11,13): error TS2304: Cannot find name 'Map'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(18,5): error TS2339: Property 'name' does not exist on type '() => void'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(21,6): error TS2339: Property 'sign' does not exist on type 'Math'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(26,6): error TS2304: Cannot find name 'Symbol'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(30,18): error TS2304: Cannot find name 'Symbol'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(34,13): error TS2304: Cannot find name 'Proxy'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(37,1): error TS2304: Cannot find name 'Reflect'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(41,5): error TS2339: Property 'flags' does not exist on type 'RegExp'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(45,5): error TS2339: Property 'includes' does not exist on type 'string'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(48,9): error TS2304: Cannot find name 'Symbol'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(52,6): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(4,18): error TS2339: Property 'from' does not exist on type 'ArrayConstructor'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(10,13): error TS2304: Cannot find name 'Map'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(17,5): error TS2339: Property 'name' does not exist on type '() => void'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(20,6): error TS2339: Property 'sign' does not exist on type 'Math'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(25,6): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(29,18): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(33,13): error TS2304: Cannot find name 'Proxy'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(36,1): error TS2304: Cannot find name 'Reflect'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(40,5): error TS2339: Property 'flags' does not exist on type 'RegExp'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(44,5): error TS2339: Property 'includes' does not exist on type 'string'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(47,9): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(51,6): error TS2304: Cannot find name 'Symbol'. ==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts (12 errors) ==== - // All will be error from using ES6 features but only include ES5 library // Using Es6 array function f(x: number, y: number, z: number) { diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js index 257df4278fe..79d8aac8bb9 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts] - // All will be error from using ES6 features but only include ES5 library // Using Es6 array function f(x: number, y: number, z: number) { diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt index f5a8b84ac29..7c0dc9a1cf2 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(8,1): error TS2322: Type 'false' is not assignable to type 'string'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(8,3): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(7,1): error TS2322: Type 'false' is not assignable to type 'string'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(7,3): error TS2304: Cannot find name 'Symbol'. ==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts (2 errors) ==== - function f(x: number, y: number, z: number) { return Array.from(arguments); } diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js index e150560cc6a..ab85c912b4d 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts] - function f(x: number, y: number, z: number) { return Array.from(arguments); } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js index b83efdce890..8fdb55a0f26 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_NoErrorDuplicateLibOptions1.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols index 62473581abe..3f2845016bb 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,61 +18,61 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 generator function* gen() { ->gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 16, 9)) +>gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 15, 9)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) } } function* gen2() { ->gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 25, 1)) +>gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 24, 1)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) } } @@ -85,23 +84,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 38, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 9)) +>a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 38, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 41, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 40, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 38, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -109,35 +108,35 @@ o.hasOwnProperty(Symbol.hasInstance); // Using ES6 promise async function out() { ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 44, 37)) return new Promise(function (resolve, reject) {}); >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 33)) ->reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 41)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 48, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 48, 41)) } declare var console: any; ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 51, 11)) out().then(() => { >out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 44, 37)) >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) console.log("Yea!"); ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 51, 11)) }); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 57, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 59, 3)) +>p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 57, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -147,37 +146,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 64, 3)) >RegExp : Symbol(RegExp, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 64, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 68, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 68, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 73, 3)) +>s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 72, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 76, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 75, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 77, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 76, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types index b259e30172d..ef39f2be751 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js index 32d7135916b..21a8fa48b1f 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_NoErrorDuplicateLibOptions2.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols index ccb78b1c367..a2b2cf6872c 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,61 +18,61 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 generator function* gen() { ->gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 16, 9)) +>gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 15, 9)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) } } function* gen2() { ->gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 25, 1)) +>gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 24, 1)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) } } @@ -85,23 +84,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 38, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 9)) +>a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 38, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 41, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 40, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 38, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -109,35 +108,35 @@ o.hasOwnProperty(Symbol.hasInstance); // Using ES6 promise async function out() { ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 44, 37)) return new Promise(function (resolve, reject) {}); >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 33)) ->reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 41)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 48, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 48, 41)) } declare var console: any; ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 51, 11)) out().then(() => { >out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 44, 37)) >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) console.log("Yea!"); ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 51, 11)) }); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 57, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 59, 3)) +>p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 57, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -147,37 +146,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 64, 3)) >RegExp : Symbol(RegExp, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 64, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 68, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 68, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 73, 3)) +>s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 72, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 76, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 75, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 77, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 76, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types index 4fa4c085bca..a238af122c0 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js index d0de3c93da0..093f3bde868 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_TargetES5UsingES6Lib.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols index 0bbffee6c86..5eba2e5dcfe 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,61 +18,61 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 generator function* gen() { ->gen : Symbol(gen, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 16, 9)) +>gen : Symbol(gen, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 15, 9)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) } } function* gen2() { ->gen2 : Symbol(gen2, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 25, 1)) +>gen2 : Symbol(gen2, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 24, 1)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) } } @@ -85,23 +84,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 38, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 9)) +>a : Symbol(a, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 38, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 41, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 40, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 38, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -109,35 +108,35 @@ o.hasOwnProperty(Symbol.hasInstance); // Using ES6 promise async function out() { ->out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 44, 37)) return new Promise(function (resolve, reject) {}); >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->resolve : Symbol(resolve, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 33)) ->reject : Symbol(reject, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 41)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 48, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 48, 41)) } declare var console: any; ->console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 51, 11)) out().then(() => { >out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) ->out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 44, 37)) >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) console.log("Yea!"); ->console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 51, 11)) }); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 57, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 59, 3)) +>p : Symbol(p, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 57, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -147,37 +146,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 64, 3)) >RegExp : Symbol(RegExp, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 64, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 68, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 68, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 73, 3)) +>s : Symbol(s, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 72, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 76, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 75, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 77, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 76, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types index 25cd47601e0..01ff3aea964 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js index 137bd1063b8..7272057499e 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_TargetES6UsingES6Lib.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols index d3d3e3d1ed6..1d3f903f880 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,27 +18,27 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 math @@ -50,23 +49,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 21, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 9)) +>a : Symbol(a, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 21, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 24, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 23, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 21, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -74,12 +73,12 @@ o.hasOwnProperty(Symbol.hasInstance); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 30, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 32, 3)) +>p : Symbol(p, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 30, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -89,37 +88,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 38, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 37, 3)) >RegExp : Symbol(RegExp, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 38, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 37, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 42, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 41, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 42, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 41, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 46, 3)) +>s : Symbol(s, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 45, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 49, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 48, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 50, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 49, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types index 5b96ce987bc..3dc6cae3aae 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js index 29e0afc711c..04f4c584ff8 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_UsingES5LibAndES6ArrayLib.ts] - // No error function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols index ce03d4cfc59..489d23c4d48 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts === - // No error function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types index a097b116186..c67585d5e19 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts === - // No error function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js index 892bc688524..7fac1a80cde 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts] - var s = Symbol(); var t = {}; var p = new Proxy(t, {}); diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols index e6f7584c471..0291ddef9c9 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts === - var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) +>s : Symbol(s, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 0, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) var t = {}; ->t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) +>t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 3, 3)) +>p : Symbol(p, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) +>t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) Reflect.ownKeys({}); >Reflect.ownKeys : Symbol(Reflect.ownKeys, Decl(lib.es2015.reflect.d.ts, --, --)) @@ -18,16 +17,16 @@ Reflect.ownKeys({}); >ownKeys : Symbol(Reflect.ownKeys, Decl(lib.es2015.reflect.d.ts, --, --)) function* idGen() { ->idGen : Symbol(idGen, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 5, 20)) +>idGen : Symbol(idGen, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 4, 20)) let i = 10; ->i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 7, 7)) while (i < 20) { ->i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 7, 7)) yield i + 2; ->i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 7, 7)) } } diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types index cceb9a1925e..281faddbc52 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts === - var s = Symbol(); >s : symbol >Symbol() : symbol diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js index 7755fc72ce8..fdb1416993c 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts] - function f(x: number, y: number, z: number) { return Array.from(arguments); } diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols index 0ed5ec38513..b00d1aba743 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts === - function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 11)) ->y : Symbol(y, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 21)) ->z : Symbol(z, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 32)) +>x : Symbol(x, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 11)) +>y : Symbol(y, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 21)) +>z : Symbol(z, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -17,10 +16,10 @@ f(1, 2, 3); // no error >f : Symbol(f, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 0)) let a = ['c', 'd']; ->a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 6, 3)) +>a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 5, 3)) a[Symbol.isConcatSpreadable] = false; ->a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 6, 3)) +>a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 5, 3)) >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types index 6accc7e7905..828e8dbb322 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts === - function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] >x : number diff --git a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js index a92cf5093e3..949a30efc8f 100644 --- a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js +++ b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationCollidingNamesInAugmentation1.ts] //// //// [map1.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols index ce701a7c59d..88a610901ed 100644 --- a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols +++ b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/map1.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map1.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map1.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map1.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map1.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface I {x0} ->I : Symbol(I, Decl(map1.ts, 5, 31), Decl(map2.ts, 4, 31)) ->x0 : Symbol(I.x0, Decl(map1.ts, 6, 17)) +>I : Symbol(I, Decl(map1.ts, 4, 31), Decl(map2.ts, 4, 31)) +>x0 : Symbol(I.x0, Decl(map1.ts, 5, 17)) } === tests/cases/compiler/map2.ts === @@ -25,7 +24,7 @@ import { Observable } from "./observable" declare module "./observable" { interface I {x1} ->I : Symbol(I, Decl(map1.ts, 5, 31), Decl(map2.ts, 4, 31)) +>I : Symbol(I, Decl(map1.ts, 4, 31), Decl(map2.ts, 4, 31)) >x1 : Symbol(I.x1, Decl(map2.ts, 5, 17)) } diff --git a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types index e87560c6a3d..a6069712269 100644 --- a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types +++ b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map1.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js index 77759306845..818c49c9edf 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationDeclarationEmit1.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols index 17e31591be0..5f619a0cdf4 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: number; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 7)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types index 6c693b2b23b..471e3ed38c3 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js index 15ca6aaf806..1dca750a614 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationDeclarationEmit2.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols index 38a0506d179..ad2f467dbe7 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: string; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) export let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 14)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) @@ -82,8 +81,8 @@ let z1 = Observable.someValue.toFixed(); let z2 = Observable.someAnotherValue.toLowerCase(); >z2 : Symbol(z2, Decl(main.ts, 6, 3)) >Observable.someAnotherValue.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >Observable : Symbol(Observable, Decl(main.ts, 0, 8)) ->someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types index ee302e6407e..bc17a6823f0 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt index 25577578ceb..cacd821168c 100644 --- a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt +++ b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt @@ -1,20 +1,18 @@ +tests/cases/compiler/x.ts(17,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. +tests/cases/compiler/x.ts(17,26): error TS2307: Cannot find module './x0'. tests/cases/compiler/x.ts(18,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. -tests/cases/compiler/x.ts(18,26): error TS2307: Cannot find module './x0'. -tests/cases/compiler/x.ts(19,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. -tests/cases/compiler/x.ts(19,21): error TS2307: Cannot find module './x0'. +tests/cases/compiler/x.ts(18,21): error TS2307: Cannot find module './x0'. +tests/cases/compiler/x.ts(19,5): error TS2666: Exports and export assignments are not permitted in module augmentations. +tests/cases/compiler/x.ts(19,19): error TS2307: Cannot find module './x0'. tests/cases/compiler/x.ts(20,5): error TS2666: Exports and export assignments are not permitted in module augmentations. -tests/cases/compiler/x.ts(20,19): error TS2307: Cannot find module './x0'. -tests/cases/compiler/x.ts(21,5): error TS2666: Exports and export assignments are not permitted in module augmentations. -tests/cases/compiler/x.ts(21,21): error TS2307: Cannot find module './x0'. -tests/cases/compiler/x.ts(25,5): error TS2666: Exports and export assignments are not permitted in module augmentations. +tests/cases/compiler/x.ts(20,21): error TS2307: Cannot find module './x0'. +tests/cases/compiler/x.ts(24,5): error TS2666: Exports and export assignments are not permitted in module augmentations. ==== tests/cases/compiler/x0.ts (0 errors) ==== - export let a = 1; ==== tests/cases/compiler/x.ts (9 errors) ==== - namespace N1 { export let x = 1; } diff --git a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js index c29bed68e51..02e2fb313c4 100644 --- a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js +++ b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/moduleAugmentationDisallowedExtensions.ts] //// //// [x0.ts] - export let a = 1; //// [x.ts] - namespace N1 { export let x = 1; } diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js index d6857a28ef1..1ef8a7cd154 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendAmbientModule1.ts] //// //// [map.ts] - import { Observable } from "observable" (Observable.prototype).map = function() { } @@ -26,7 +25,6 @@ declare module "observable" { } //// [main.ts] - /// import { Observable } from "observable" import "./map"; diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols index 62ac82b6953..3a632fce461 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols @@ -1,72 +1,70 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) import "./map"; let x: Observable; ->x : Symbol(x, Decl(main.ts, 5, 3)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) let y = x.map(x => x + 1); ->y : Symbol(y, Decl(main.ts, 6, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 5, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 6, 14)) ->x : Symbol(x, Decl(main.ts, 6, 14)) +>y : Symbol(y, Decl(main.ts, 5, 3)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 5, 14)) +>x : Symbol(x, Decl(main.ts, 5, 14)) === tests/cases/compiler/map.ts === - import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) let someAnotherValue: number; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.d.ts === declare module "observable" { class Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.d.ts, 1, 25)) >pred : Symbol(pred, Decl(observable.d.ts, 2, 15)) >e : Symbol(e, Decl(observable.d.ts, 2, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) let someValue: number; >someValue : Symbol(someValue, Decl(observable.d.ts, 5, 11)) diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types index 6c2c8c8e781..f27a85de25a 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" >Observable : typeof Observable @@ -23,7 +22,6 @@ let y = x.map(x => x + 1); >1 : 1 === tests/cases/compiler/map.ts === - import { Observable } from "observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js index eee03576336..23e61952e30 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendAmbientModule2.ts] //// //// [map.ts] - import { Observable } from "observable" (Observable.prototype).map = function() { } @@ -26,7 +25,6 @@ declare module "observable" { } //// [main.ts] - /// import { Observable } from "observable" import "./map"; diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols index bbd3b6e5f79..c7bf4920208 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols @@ -1,88 +1,86 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) import "./map"; let x: Observable; ->x : Symbol(x, Decl(main.ts, 5, 3)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) let y = x.map(x => x + 1); ->y : Symbol(y, Decl(main.ts, 6, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 5, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 6, 14)) ->x : Symbol(x, Decl(main.ts, 6, 14)) +>y : Symbol(y, Decl(main.ts, 5, 3)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 5, 14)) +>x : Symbol(x, Decl(main.ts, 5, 14)) let z1 = Observable.someValue.toFixed(); ->z1 : Symbol(z1, Decl(main.ts, 7, 3)) +>z1 : Symbol(z1, Decl(main.ts, 6, 3)) >Observable.someValue.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >Observable.someValue : Symbol(Observable.someValue, Decl(observable.d.ts, 5, 18)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) >someValue : Symbol(Observable.someValue, Decl(observable.d.ts, 5, 18)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) let z2 = Observable.someAnotherValue.toLowerCase(); ->z2 : Symbol(z2, Decl(main.ts, 8, 3)) +>z2 : Symbol(z2, Decl(main.ts, 7, 3)) >Observable.someAnotherValue.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) ->someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) +>someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) === tests/cases/compiler/map.ts === - import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) let someAnotherValue: string; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.d.ts === declare module "observable" { class Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.d.ts, 1, 25)) >pred : Symbol(pred, Decl(observable.d.ts, 2, 15)) >e : Symbol(e, Decl(observable.d.ts, 2, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) export let someValue: number; >someValue : Symbol(someValue, Decl(observable.d.ts, 5, 18)) diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types index b938cf9944e..2c82dcbf849 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" >Observable : typeof Observable @@ -41,7 +40,6 @@ let z2 = Observable.someAnotherValue.toLowerCase(); >toLowerCase : () => string === tests/cases/compiler/map.ts === - import { Observable } from "observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.js b/tests/baselines/reference/moduleAugmentationExtendFileModule1.js index 9d15f3fe387..85b30f4d002 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.js +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendFileModule1.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols b/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols index 17e31591be0..5f619a0cdf4 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: number; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 7)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.types b/tests/baselines/reference/moduleAugmentationExtendFileModule1.types index 6c693b2b23b..471e3ed38c3 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.types +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.js b/tests/baselines/reference/moduleAugmentationExtendFileModule2.js index 072c62862e3..4c67c63d1bb 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.js +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendFileModule2.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols b/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols index 38a0506d179..ad2f467dbe7 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: string; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) export let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 14)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) @@ -82,8 +81,8 @@ let z1 = Observable.someValue.toFixed(); let z2 = Observable.someAnotherValue.toLowerCase(); >z2 : Symbol(z2, Decl(main.ts, 6, 3)) >Observable.someAnotherValue.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >Observable : Symbol(Observable, Decl(main.ts, 0, 8)) ->someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.types b/tests/baselines/reference/moduleAugmentationExtendFileModule2.types index ee302e6407e..bc17a6823f0 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.types +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationGlobal1.js b/tests/baselines/reference/moduleAugmentationGlobal1.js index 2ef6441692f..ae4042768e8 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal1.js +++ b/tests/baselines/reference/moduleAugmentationGlobal1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationGlobal1.ts] //// //// [f1.ts] - export class A {x: number;} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationGlobal1.symbols b/tests/baselines/reference/moduleAugmentationGlobal1.symbols index 53cc4500e07..1dcb80409b7 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal1.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal1.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/f1.ts === - export class A {x: number;} >A : Symbol(A, Decl(f1.ts, 0, 0)) ->x : Symbol(A.x, Decl(f1.ts, 1, 16)) +>x : Symbol(A.x, Decl(f1.ts, 0, 16)) === tests/cases/compiler/f2.ts === import {A} from "./f1"; @@ -27,9 +26,9 @@ let x = [1]; let y = x.getA().x; >y : Symbol(y, Decl(f2.ts, 10, 3)) ->x.getA().x : Symbol(A.x, Decl(f1.ts, 1, 16)) +>x.getA().x : Symbol(A.x, Decl(f1.ts, 0, 16)) >x.getA : Symbol(Array.getA, Decl(f2.ts, 4, 24)) >x : Symbol(x, Decl(f2.ts, 9, 3)) >getA : Symbol(Array.getA, Decl(f2.ts, 4, 24)) ->x : Symbol(A.x, Decl(f1.ts, 1, 16)) +>x : Symbol(A.x, Decl(f1.ts, 0, 16)) diff --git a/tests/baselines/reference/moduleAugmentationGlobal1.types b/tests/baselines/reference/moduleAugmentationGlobal1.types index 48ed21e2145..fff55461b7d 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal1.types +++ b/tests/baselines/reference/moduleAugmentationGlobal1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {x: number;} >A : A >x : number diff --git a/tests/baselines/reference/moduleAugmentationGlobal2.js b/tests/baselines/reference/moduleAugmentationGlobal2.js index 1806ceae9a1..28f6d3babf0 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal2.js +++ b/tests/baselines/reference/moduleAugmentationGlobal2.js @@ -1,10 +1,8 @@ //// [tests/cases/compiler/moduleAugmentationGlobal2.ts] //// //// [f1.ts] - export class A {}; //// [f2.ts] - // change the shape of Array import {A} from "./f1"; diff --git a/tests/baselines/reference/moduleAugmentationGlobal2.symbols b/tests/baselines/reference/moduleAugmentationGlobal2.symbols index 0e6d8a6024d..b69e4eed013 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal2.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal2.symbols @@ -1,34 +1,32 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : Symbol(A, Decl(f1.ts, 0, 0)) === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; ->A : Symbol(A, Decl(f2.ts, 2, 8)) +>A : Symbol(A, Decl(f2.ts, 1, 8)) declare global { ->global : Symbol(global, Decl(f2.ts, 2, 23)) +>global : Symbol(global, Decl(f2.ts, 1, 23)) interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 16)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 5, 20)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 3, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 20)) getCountAsString(): string; ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) } } let x = [1]; ->x : Symbol(x, Decl(f2.ts, 10, 3)) +>x : Symbol(x, Decl(f2.ts, 9, 3)) let y = x.getCountAsString().toLowerCase(); ->y : Symbol(y, Decl(f2.ts, 11, 3)) +>y : Symbol(y, Decl(f2.ts, 10, 3)) >x.getCountAsString().toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) ->x : Symbol(x, Decl(f2.ts, 10, 3)) ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) +>x : Symbol(x, Decl(f2.ts, 9, 3)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationGlobal2.types b/tests/baselines/reference/moduleAugmentationGlobal2.types index f80f0ec7c72..ef6239e1176 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal2.types +++ b/tests/baselines/reference/moduleAugmentationGlobal2.types @@ -1,10 +1,8 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : A === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; >A : typeof A diff --git a/tests/baselines/reference/moduleAugmentationGlobal3.js b/tests/baselines/reference/moduleAugmentationGlobal3.js index 9cb08f2b866..d744d3017b9 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal3.js +++ b/tests/baselines/reference/moduleAugmentationGlobal3.js @@ -1,10 +1,8 @@ //// [tests/cases/compiler/moduleAugmentationGlobal3.ts] //// //// [f1.ts] - export class A {}; //// [f2.ts] - // change the shape of Array import {A} from "./f1"; diff --git a/tests/baselines/reference/moduleAugmentationGlobal3.symbols b/tests/baselines/reference/moduleAugmentationGlobal3.symbols index 1521fbb6e34..f572214ad91 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal3.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal3.symbols @@ -1,23 +1,21 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : Symbol(A, Decl(f1.ts, 0, 0)) === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; ->A : Symbol(A, Decl(f2.ts, 2, 8)) +>A : Symbol(A, Decl(f2.ts, 1, 8)) declare global { ->global : Symbol(global, Decl(f2.ts, 2, 23)) +>global : Symbol(global, Decl(f2.ts, 1, 23)) interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 16)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 5, 20)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 3, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 20)) getCountAsString(): string; ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) } } @@ -30,8 +28,8 @@ let x = [1]; let y = x.getCountAsString().toLowerCase(); >y : Symbol(y, Decl(f3.ts, 3, 3)) >x.getCountAsString().toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) >x : Symbol(x, Decl(f3.ts, 2, 3)) ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationGlobal3.types b/tests/baselines/reference/moduleAugmentationGlobal3.types index 3b9ed24a452..fa1ecf6332e 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal3.types +++ b/tests/baselines/reference/moduleAugmentationGlobal3.types @@ -1,10 +1,8 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : A === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; >A : typeof A diff --git a/tests/baselines/reference/moduleAugmentationGlobal4.js b/tests/baselines/reference/moduleAugmentationGlobal4.js index 194d06aeb80..a47e4c6673a 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal4.js +++ b/tests/baselines/reference/moduleAugmentationGlobal4.js @@ -1,13 +1,11 @@ //// [tests/cases/compiler/moduleAugmentationGlobal4.ts] //// //// [f1.ts] - declare global { interface Something {x} } export {}; //// [f2.ts] - declare global { interface Something {y} } diff --git a/tests/baselines/reference/moduleAugmentationGlobal4.symbols b/tests/baselines/reference/moduleAugmentationGlobal4.symbols index 6aaa587234b..5a2ed5c76e7 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal4.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal4.symbols @@ -1,21 +1,19 @@ === tests/cases/compiler/f1.ts === - declare global { >global : Symbol(global, Decl(f1.ts, 0, 0)) interface Something {x} ->Something : Symbol(Something, Decl(f1.ts, 1, 16), Decl(f2.ts, 1, 16)) ->x : Symbol(Something.x, Decl(f1.ts, 2, 25)) +>Something : Symbol(Something, Decl(f1.ts, 0, 16), Decl(f2.ts, 0, 16)) +>x : Symbol(Something.x, Decl(f1.ts, 1, 25)) } export {}; === tests/cases/compiler/f2.ts === - declare global { >global : Symbol(global, Decl(f2.ts, 0, 0)) interface Something {y} ->Something : Symbol(Something, Decl(f1.ts, 1, 16), Decl(f2.ts, 1, 16)) ->y : Symbol(Something.y, Decl(f2.ts, 2, 25)) +>Something : Symbol(Something, Decl(f1.ts, 0, 16), Decl(f2.ts, 0, 16)) +>y : Symbol(Something.y, Decl(f2.ts, 1, 25)) } export {}; === tests/cases/compiler/f3.ts === diff --git a/tests/baselines/reference/moduleAugmentationGlobal4.types b/tests/baselines/reference/moduleAugmentationGlobal4.types index e3e780d69ff..f577b591694 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal4.types +++ b/tests/baselines/reference/moduleAugmentationGlobal4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - declare global { >global : any @@ -9,7 +8,6 @@ declare global { } export {}; === tests/cases/compiler/f2.ts === - declare global { >global : any diff --git a/tests/baselines/reference/moduleAugmentationGlobal5.js b/tests/baselines/reference/moduleAugmentationGlobal5.js index 43d8c6b958b..55433fcf6d6 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal5.js +++ b/tests/baselines/reference/moduleAugmentationGlobal5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationGlobal5.ts] //// //// [f1.d.ts] - declare module "A" { global { interface Something {x} diff --git a/tests/baselines/reference/moduleAugmentationGlobal5.symbols b/tests/baselines/reference/moduleAugmentationGlobal5.symbols index 4c4693601e8..ad5ab1cd4cd 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal5.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal5.symbols @@ -6,14 +6,13 @@ No type information for this code.import "B"; No type information for this code. No type information for this code. No type information for this code.=== tests/cases/compiler/f1.d.ts === - declare module "A" { global { ->global : Symbol(global, Decl(f1.d.ts, 1, 20)) +>global : Symbol(global, Decl(f1.d.ts, 0, 20)) interface Something {x} ->Something : Symbol(Something, Decl(f1.d.ts, 2, 12), Decl(f2.d.ts, 1, 12)) ->x : Symbol(Something.x, Decl(f1.d.ts, 3, 29)) +>Something : Symbol(Something, Decl(f1.d.ts, 1, 12), Decl(f2.d.ts, 1, 12)) +>x : Symbol(Something.x, Decl(f1.d.ts, 2, 29)) } } === tests/cases/compiler/f2.d.ts === @@ -22,7 +21,7 @@ declare module "B" { >global : Symbol(global, Decl(f2.d.ts, 0, 20)) interface Something {y} ->Something : Symbol(Something, Decl(f1.d.ts, 2, 12), Decl(f2.d.ts, 1, 12)) +>Something : Symbol(Something, Decl(f1.d.ts, 1, 12), Decl(f2.d.ts, 1, 12)) >y : Symbol(Something.y, Decl(f2.d.ts, 2, 29)) } } diff --git a/tests/baselines/reference/moduleAugmentationGlobal5.types b/tests/baselines/reference/moduleAugmentationGlobal5.types index b2e6139eb26..8cb9fdeb3f9 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal5.types +++ b/tests/baselines/reference/moduleAugmentationGlobal5.types @@ -6,7 +6,6 @@ No type information for this code.import "B"; No type information for this code. No type information for this code. No type information for this code.=== tests/cases/compiler/f1.d.ts === - declare module "A" { global { >global : any diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.js b/tests/baselines/reference/moduleAugmentationImportsAndExports1.js index 66ce39e8d84..27d69dd181c 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports1.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols b/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols index 84daab19bf5..db4af0fa34e 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0), Decl(f3.ts, 4, 23)) diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.types b/tests/baselines/reference/moduleAugmentationImportsAndExports1.types index 886a04b54ef..5ab340b3aed 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt b/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt index 9c49d38572b..5f57081357e 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt @@ -11,7 +11,6 @@ tests/cases/compiler/f4.ts(5,11): error TS2339: Property 'foo' does not exist on ==== tests/cases/compiler/f1.ts (0 errors) ==== - export class A {} ==== tests/cases/compiler/f2.ts (0 errors) ==== diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports2.js b/tests/baselines/reference/moduleAugmentationImportsAndExports2.js index e79f2e58484..32d7950574d 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports2.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports2.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt b/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt index c2c43c85af3..33732c0552f 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/f3.ts(13,16): error TS4000: Import declaration 'C' is using ==== tests/cases/compiler/f1.ts (0 errors) ==== - export class A {} ==== tests/cases/compiler/f2.ts (0 errors) ==== diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports3.js b/tests/baselines/reference/moduleAugmentationImportsAndExports3.js index c7c13ea7861..12bcffd00f6 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports3.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports3.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.js b/tests/baselines/reference/moduleAugmentationImportsAndExports4.js index 9cdf76b90a5..041c2c71d09 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports4.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols b/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols index fd1ec87b2a2..a65f0e4f339 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0), Decl(f3.ts, 12, 23)) diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.types b/tests/baselines/reference/moduleAugmentationImportsAndExports4.types index 454dc5d27ec..1dc7a9da1e8 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt b/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt index 5f783453888..962386c730a 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/f3.ts(11,12): error TS4000: Import declaration 'C' is using ==== tests/cases/compiler/f1.ts (0 errors) ==== - export class A {} ==== tests/cases/compiler/f2.ts (0 errors) ==== diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports5.js b/tests/baselines/reference/moduleAugmentationImportsAndExports5.js index c7f7990608e..25a3702db64 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports5.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports5.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.js b/tests/baselines/reference/moduleAugmentationImportsAndExports6.js index 0f19e737ec5..3796d70f2d3 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports6.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols b/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols index 5c9be6d9448..5e4ead631bc 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0), Decl(f3.ts, 12, 23)) diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.types b/tests/baselines/reference/moduleAugmentationImportsAndExports6.types index 0c201599b52..544514d2855 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule1.js b/tests/baselines/reference/moduleAugmentationInAmbientModule1.js index 4cdef37a4f7..13e6ef2c4fa 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule1.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule1.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule1.ts] //// //// [O.d.ts] - - declare module "Observable" { class Observable {} } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols index 6d9c185ca08..b4f22e07d4c 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols @@ -9,37 +9,35 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 2, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 7, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 13, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 13, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 7, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) === tests/cases/compiler/O.d.ts === - - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 2, 29), Decl(O.d.ts, 12, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 6, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 7, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 11, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 2, 29), Decl(O.d.ts, 12, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 13, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 11, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule1.types b/tests/baselines/reference/moduleAugmentationInAmbientModule1.types index 0be2a787cb6..5c0d6cb29c6 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule1.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule1.types @@ -17,8 +17,6 @@ x.foo().x; >x : number === tests/cases/compiler/O.d.ts === - - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule2.js b/tests/baselines/reference/moduleAugmentationInAmbientModule2.js index 536931ee61f..91edc37e0fa 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule2.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule2.ts] //// //// [O.d.ts] - declare module "Observable" { class Observable {} } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols index 5bf797dcf08..07758a58469 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols @@ -10,36 +10,35 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 2, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 4, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 5, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule2.types b/tests/baselines/reference/moduleAugmentationInAmbientModule2.types index 31ea8904c2a..e72a8b66fdb 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule2.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule2.types @@ -18,7 +18,6 @@ x.foo().x; >x : number === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule3.js b/tests/baselines/reference/moduleAugmentationInAmbientModule3.js index 37253ab7e5b..6a572a2a1d2 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule3.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule3.ts] //// //// [O.d.ts] - declare module "Observable" { class Observable {} } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols index 2bde1316107..6fd1f788377 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols @@ -10,59 +10,58 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 2, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 4, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) x.foo2().x2; ->x.foo2().x2 : Symbol(Cls2.x2, Decl(O.d.ts, 19, 16)) ->x.foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 21, 30)) +>x.foo2().x2 : Symbol(Cls2.x2, Decl(O.d.ts, 18, 16)) +>x.foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 20, 30)) >x : Symbol(x, Decl(main.ts, 4, 3)) ->foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 21, 30)) ->x2 : Symbol(Cls2.x2, Decl(O.d.ts, 19, 16)) +>foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 20, 30)) +>x2 : Symbol(Cls2.x2, Decl(O.d.ts, 18, 16)) === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O.d.ts, 20, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O.d.ts, 19, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 5, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O.d.ts, 20, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O.d.ts, 19, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } declare module "Map" { class Cls2 { x2: number } ->Cls2 : Symbol(Cls2, Decl(O.d.ts, 18, 22)) ->x2 : Symbol(Cls2.x2, Decl(O.d.ts, 19, 16)) +>Cls2 : Symbol(Cls2, Decl(O.d.ts, 17, 22)) +>x2 : Symbol(Cls2.x2, Decl(O.d.ts, 18, 16)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O.d.ts, 20, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O.d.ts, 19, 25)) foo2(): Cls2; ->foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 21, 30)) ->Cls2 : Symbol(Cls2, Decl(O.d.ts, 18, 22)) +>foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 20, 30)) +>Cls2 : Symbol(Cls2, Decl(O.d.ts, 17, 22)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule3.types b/tests/baselines/reference/moduleAugmentationInAmbientModule3.types index 2cec5edc6bf..56dca6707e9 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule3.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule3.types @@ -26,7 +26,6 @@ x.foo2().x2; >x2 : number === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule4.js b/tests/baselines/reference/moduleAugmentationInAmbientModule4.js index 0c861447b46..74b101c7275 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule4.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule4.ts] //// //// [O.d.ts] - declare module "Observable" { class Observable {} } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols index 6e01ff8a204..5d19e07ebbb 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols @@ -11,11 +11,11 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 3, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 5, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) x.foo2().x2; >x.foo2().x2 : Symbol(Cls2.x2, Decl(O2.d.ts, 1, 16)) @@ -25,29 +25,28 @@ x.foo2().x2; >x2 : Symbol(Cls2.x2, Decl(O2.d.ts, 1, 16)) === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O2.d.ts, 2, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O2.d.ts, 2, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 5, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O2.d.ts, 2, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O2.d.ts, 2, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } @@ -60,7 +59,7 @@ declare module "Map" { module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O2.d.ts, 2, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O2.d.ts, 2, 25)) foo2(): Cls2; >foo2 : Symbol(Observable.foo2, Decl(O2.d.ts, 3, 30)) diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule4.types b/tests/baselines/reference/moduleAugmentationInAmbientModule4.types index 04791aef860..d8158cef618 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule4.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule4.types @@ -27,7 +27,6 @@ x.foo2().x2; >x2 : number === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule5.js b/tests/baselines/reference/moduleAugmentationInAmbientModule5.js index ac202784f43..4f99c79fa18 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule5.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule5.ts] //// //// [array.d.ts] - declare module "A" { class A { x: number; } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols index a8cc1a3412e..59d3002dd1c 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols @@ -7,34 +7,33 @@ let x = [1]; let y = x.getA().x; >y : Symbol(y, Decl(f.ts, 4, 3)) ->x.getA().x : Symbol(A.x, Decl(array.d.ts, 2, 13)) ->x.getA : Symbol(Array.getA, Decl(array.d.ts, 8, 28)) +>x.getA().x : Symbol(A.x, Decl(array.d.ts, 1, 13)) +>x.getA : Symbol(Array.getA, Decl(array.d.ts, 7, 28)) >x : Symbol(x, Decl(f.ts, 3, 3)) ->getA : Symbol(Array.getA, Decl(array.d.ts, 8, 28)) ->x : Symbol(A.x, Decl(array.d.ts, 2, 13)) +>getA : Symbol(Array.getA, Decl(array.d.ts, 7, 28)) +>x : Symbol(A.x, Decl(array.d.ts, 1, 13)) === tests/cases/compiler/array.d.ts === - declare module "A" { class A { x: number; } ->A : Symbol(A, Decl(array.d.ts, 1, 20)) ->x : Symbol(A.x, Decl(array.d.ts, 2, 13)) +>A : Symbol(A, Decl(array.d.ts, 0, 20)) +>x : Symbol(A.x, Decl(array.d.ts, 1, 13)) } declare module "array" { import {A} from "A"; ->A : Symbol(A, Decl(array.d.ts, 6, 12)) +>A : Symbol(A, Decl(array.d.ts, 5, 12)) global { ->global : Symbol(global, Decl(array.d.ts, 6, 24)) +>global : Symbol(global, Decl(array.d.ts, 5, 24)) interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(array.d.ts, 7, 12)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(array.d.ts, 8, 24)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(array.d.ts, 6, 12)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(array.d.ts, 7, 24)) getA(): A; ->getA : Symbol(Array.getA, Decl(array.d.ts, 8, 28)) ->A : Symbol(A, Decl(array.d.ts, 6, 12)) +>getA : Symbol(Array.getA, Decl(array.d.ts, 7, 28)) +>A : Symbol(A, Decl(array.d.ts, 5, 12)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule5.types b/tests/baselines/reference/moduleAugmentationInAmbientModule5.types index d6d81f97a3a..513bf35460d 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule5.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule5.types @@ -17,7 +17,6 @@ let y = x.getA().x; >x : number === tests/cases/compiler/array.d.ts === - declare module "A" { class A { x: number; } >A : A diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.js b/tests/baselines/reference/moduleAugmentationNoNewNames.js index 4376c23a7f8..0887377bc58 100644 --- a/tests/baselines/reference/moduleAugmentationNoNewNames.js +++ b/tests/baselines/reference/moduleAugmentationNoNewNames.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationNoNewNames.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.symbols b/tests/baselines/reference/moduleAugmentationNoNewNames.symbols index a340d3820a2..beb60f82972 100644 --- a/tests/baselines/reference/moduleAugmentationNoNewNames.symbols +++ b/tests/baselines/reference/moduleAugmentationNoNewNames.symbols @@ -1,59 +1,58 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } class Bar {} ->Bar : Symbol(Bar, Decl(map.ts, 8, 5)) +>Bar : Symbol(Bar, Decl(map.ts, 7, 5)) let y: number, z: string; ->y : Symbol(y, Decl(map.ts, 10, 7)) ->z : Symbol(z, Decl(map.ts, 10, 18)) +>y : Symbol(y, Decl(map.ts, 9, 7)) +>z : Symbol(z, Decl(map.ts, 9, 18)) let {a: x, b: x1}: {a: number, b: number}; ->a : Symbol(a, Decl(map.ts, 11, 24)) ->x : Symbol(x, Decl(map.ts, 11, 9)) ->b : Symbol(b, Decl(map.ts, 11, 34)) ->x1 : Symbol(x1, Decl(map.ts, 11, 14)) ->a : Symbol(a, Decl(map.ts, 11, 24)) ->b : Symbol(b, Decl(map.ts, 11, 34)) +>a : Symbol(a, Decl(map.ts, 10, 24)) +>x : Symbol(x, Decl(map.ts, 10, 9)) +>b : Symbol(b, Decl(map.ts, 10, 34)) +>x1 : Symbol(x1, Decl(map.ts, 10, 14)) +>a : Symbol(a, Decl(map.ts, 10, 24)) +>b : Symbol(b, Decl(map.ts, 10, 34)) module Z {} ->Z : Symbol(Z, Decl(map.ts, 11, 46)) +>Z : Symbol(Z, Decl(map.ts, 10, 46)) } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } === tests/cases/compiler/main.ts === @@ -68,9 +67,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.types b/tests/baselines/reference/moduleAugmentationNoNewNames.types index 06eab66c8d1..17eadaee707 100644 --- a/tests/baselines/reference/moduleAugmentationNoNewNames.types +++ b/tests/baselines/reference/moduleAugmentationNoNewNames.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationsBundledOutput1.js b/tests/baselines/reference/moduleAugmentationsBundledOutput1.js index 9ad2aa842d0..6a37e44264b 100644 --- a/tests/baselines/reference/moduleAugmentationsBundledOutput1.js +++ b/tests/baselines/reference/moduleAugmentationsBundledOutput1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsBundledOutput1.ts] //// //// [m1.ts] - export class Cls { } diff --git a/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols b/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols index 5f98b39c228..b701349c5f1 100644 --- a/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols +++ b/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - export class Cls { >Cls : Symbol(Cls, Decl(m1.ts, 0, 0), Decl(m2.ts, 4, 23), Decl(m2.ts, 10, 23), Decl(m4.ts, 5, 23), Decl(m4.ts, 11, 23)) } diff --git a/tests/baselines/reference/moduleAugmentationsBundledOutput1.types b/tests/baselines/reference/moduleAugmentationsBundledOutput1.types index c3cac91fa38..8e0effacb44 100644 --- a/tests/baselines/reference/moduleAugmentationsBundledOutput1.types +++ b/tests/baselines/reference/moduleAugmentationsBundledOutput1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - export class Cls { >Cls : Cls } diff --git a/tests/baselines/reference/moduleAugmentationsImports1.js b/tests/baselines/reference/moduleAugmentationsImports1.js index 116c5c5e830..9e40067c2fe 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.js +++ b/tests/baselines/reference/moduleAugmentationsImports1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports1.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports1.symbols b/tests/baselines/reference/moduleAugmentationsImports1.symbols index 685ee9bb31c..4a91852b8d7 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.ts, 9, 22), Decl(d.ts, 15, 22)) diff --git a/tests/baselines/reference/moduleAugmentationsImports1.types b/tests/baselines/reference/moduleAugmentationsImports1.types index bf0bfee0a7a..e708b574aaf 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.types +++ b/tests/baselines/reference/moduleAugmentationsImports1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationsImports2.js b/tests/baselines/reference/moduleAugmentationsImports2.js index e13cbd8f3dd..5955cd10e59 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.js +++ b/tests/baselines/reference/moduleAugmentationsImports2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports2.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports2.symbols b/tests/baselines/reference/moduleAugmentationsImports2.symbols index 126e407da8a..ef023427597 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.ts, 7, 22), Decl(e.ts, 5, 22)) diff --git a/tests/baselines/reference/moduleAugmentationsImports2.types b/tests/baselines/reference/moduleAugmentationsImports2.types index 56b40625600..70d7e8a7600 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.types +++ b/tests/baselines/reference/moduleAugmentationsImports2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationsImports3.js b/tests/baselines/reference/moduleAugmentationsImports3.js index a4a6ccea849..20ff1b25271 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.js +++ b/tests/baselines/reference/moduleAugmentationsImports3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports3.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports3.symbols b/tests/baselines/reference/moduleAugmentationsImports3.symbols index fba58ffad8a..4118ce3e9f2 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports3.symbols @@ -31,7 +31,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.d.ts, 3, 16), Decl(e.ts, 6, 22)) diff --git a/tests/baselines/reference/moduleAugmentationsImports3.types b/tests/baselines/reference/moduleAugmentationsImports3.types index 04d17296c56..030d2af80da 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.types +++ b/tests/baselines/reference/moduleAugmentationsImports3.types @@ -35,7 +35,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : () => string === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationsImports4.js b/tests/baselines/reference/moduleAugmentationsImports4.js index 4be17a61edb..ee66546983d 100644 --- a/tests/baselines/reference/moduleAugmentationsImports4.js +++ b/tests/baselines/reference/moduleAugmentationsImports4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports4.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports4.symbols b/tests/baselines/reference/moduleAugmentationsImports4.symbols index 77b5431850e..0c92e2c510b 100644 --- a/tests/baselines/reference/moduleAugmentationsImports4.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports4.symbols @@ -32,7 +32,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.d.ts, 3, 16), Decl(e.d.ts, 5, 16)) diff --git a/tests/baselines/reference/moduleAugmentationsImports4.types b/tests/baselines/reference/moduleAugmentationsImports4.types index 53d570e14e6..7f4a190291f 100644 --- a/tests/baselines/reference/moduleAugmentationsImports4.types +++ b/tests/baselines/reference/moduleAugmentationsImports4.types @@ -36,7 +36,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : () => string === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleMergeConstructor.js b/tests/baselines/reference/moduleMergeConstructor.js index 88531532acc..5ecaf8365d8 100644 --- a/tests/baselines/reference/moduleMergeConstructor.js +++ b/tests/baselines/reference/moduleMergeConstructor.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleMergeConstructor.ts] //// //// [foo.d.ts] - declare module "foo" { export class Foo { constructor(); diff --git a/tests/baselines/reference/moduleMergeConstructor.symbols b/tests/baselines/reference/moduleMergeConstructor.symbols index 8d9a773f144..bad5f3d14f4 100644 --- a/tests/baselines/reference/moduleMergeConstructor.symbols +++ b/tests/baselines/reference/moduleMergeConstructor.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/foo.d.ts === - declare module "foo" { export class Foo { ->Foo : Symbol(Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) constructor(); method1(): any; ->method1 : Symbol(Foo.method1, Decl(foo.d.ts, 3, 22)) +>method1 : Symbol(Foo.method1, Decl(foo.d.ts, 2, 22)) } } === tests/cases/compiler/foo-ext.d.ts === declare module "foo" { export interface Foo { ->Foo : Symbol(Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) method2(): any; >method2 : Symbol(Foo.method2, Decl(foo-ext.d.ts, 1, 26)) @@ -30,16 +29,16 @@ class Test { bar: foo.Foo; >bar : Symbol(Test.bar, Decl(index.ts, 2, 12)) >foo : Symbol(foo, Decl(index.ts, 0, 6)) ->Foo : Symbol(foo.Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(foo.Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) constructor() { this.bar = new foo.Foo(); >this.bar : Symbol(Test.bar, Decl(index.ts, 2, 12)) >this : Symbol(Test, Decl(index.ts, 0, 27)) >bar : Symbol(Test.bar, Decl(index.ts, 2, 12)) ->foo.Foo : Symbol(foo.Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>foo.Foo : Symbol(foo.Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) >foo : Symbol(foo, Decl(index.ts, 0, 6)) ->Foo : Symbol(foo.Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(foo.Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) } } diff --git a/tests/baselines/reference/moduleMergeConstructor.types b/tests/baselines/reference/moduleMergeConstructor.types index 48a2f010293..5de02bba55c 100644 --- a/tests/baselines/reference/moduleMergeConstructor.types +++ b/tests/baselines/reference/moduleMergeConstructor.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.d.ts === - declare module "foo" { export class Foo { >Foo : Foo diff --git a/tests/baselines/reference/moduleOuterQualification.js b/tests/baselines/reference/moduleOuterQualification.js index 83c79703f99..c18e5d758ff 100644 --- a/tests/baselines/reference/moduleOuterQualification.js +++ b/tests/baselines/reference/moduleOuterQualification.js @@ -1,5 +1,4 @@ //// [moduleOuterQualification.ts] - declare module outer { interface Beta { } module inner { diff --git a/tests/baselines/reference/moduleOuterQualification.symbols b/tests/baselines/reference/moduleOuterQualification.symbols index 32791347258..16b80668663 100644 --- a/tests/baselines/reference/moduleOuterQualification.symbols +++ b/tests/baselines/reference/moduleOuterQualification.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/moduleOuterQualification.ts === - declare module outer { >outer : Symbol(outer, Decl(moduleOuterQualification.ts, 0, 0)) interface Beta { } ->Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 1, 22)) +>Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 0, 22)) module inner { ->inner : Symbol(inner, Decl(moduleOuterQualification.ts, 2, 20)) +>inner : Symbol(inner, Decl(moduleOuterQualification.ts, 1, 20)) // .d.ts emit: should be 'extends outer.Beta' export interface Beta extends outer.Beta { } ->Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 3, 16)) ->outer.Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 1, 22)) +>Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 2, 16)) +>outer.Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 0, 22)) >outer : Symbol(outer, Decl(moduleOuterQualification.ts, 0, 0)) ->Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 1, 22)) +>Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 0, 22)) } } diff --git a/tests/baselines/reference/moduleOuterQualification.types b/tests/baselines/reference/moduleOuterQualification.types index 7cfab635023..e6388b7ee78 100644 --- a/tests/baselines/reference/moduleOuterQualification.types +++ b/tests/baselines/reference/moduleOuterQualification.types @@ -1,5 +1,4 @@ === tests/cases/compiler/moduleOuterQualification.ts === - declare module outer { >outer : any diff --git a/tests/baselines/reference/moduleResolutionNoResolve.js b/tests/baselines/reference/moduleResolutionNoResolve.js index 86f681fa27a..d1b5315903c 100644 --- a/tests/baselines/reference/moduleResolutionNoResolve.js +++ b/tests/baselines/reference/moduleResolutionNoResolve.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleResolutionNoResolve.ts] //// //// [a.ts] - import a = require('./b'); //// [b.ts] diff --git a/tests/baselines/reference/moduleResolutionNoResolve.symbols b/tests/baselines/reference/moduleResolutionNoResolve.symbols index 17ccfeab496..c0fa4efda15 100644 --- a/tests/baselines/reference/moduleResolutionNoResolve.symbols +++ b/tests/baselines/reference/moduleResolutionNoResolve.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - import a = require('./b'); >a : Symbol(a, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/moduleResolutionNoResolve.types b/tests/baselines/reference/moduleResolutionNoResolve.types index dbec43bf1a2..02c61cfb6b3 100644 --- a/tests/baselines/reference/moduleResolutionNoResolve.types +++ b/tests/baselines/reference/moduleResolutionNoResolve.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - import a = require('./b'); >a : typeof a diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.js b/tests/baselines/reference/moduleResolutionWithExtensions.js index b9a644a7209..c1e0310e995 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions.js +++ b/tests/baselines/reference/moduleResolutionWithExtensions.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts] //// //// [a.ts] - export default 0; // No extension: '.ts' added diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.symbols b/tests/baselines/reference/moduleResolutionWithExtensions.symbols index eaaa1d51cc0..5a7f9e5b62a 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions.symbols +++ b/tests/baselines/reference/moduleResolutionWithExtensions.symbols @@ -1,6 +1,5 @@ === /src/a.ts === - -No type information for this code.export default 0; +export default 0; No type information for this code. No type information for this code.// No extension: '.ts' added No type information for this code.=== /src/b.ts === diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.types b/tests/baselines/reference/moduleResolutionWithExtensions.types index 60196f2b25d..25eb5ad1fee 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions.types +++ b/tests/baselines/reference/moduleResolutionWithExtensions.types @@ -1,6 +1,5 @@ === /src/a.ts === - -No type information for this code.export default 0; +export default 0; No type information for this code. No type information for this code.// No extension: '.ts' added No type information for this code.=== /src/b.ts === diff --git a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt index aa415a95b1b..958837f7a0b 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt +++ b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt @@ -16,7 +16,6 @@ ==== /tsx.tsx (0 errors) ==== - ==== /jsx.jsx (0 errors) ==== ==== /js.js (0 errors) ==== diff --git a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js index 6bce8b8d3c5..eb6057f9693 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js +++ b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleResolutionWithExtensions_notSupported.ts] //// //// [tsx.tsx] - //// [jsx.jsx] diff --git a/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js b/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js index a9dc91d9a55..b02d23302ae 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js +++ b/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleResolutionWithExtensions_preferTs.ts] //// //// [b.js] - //// [index.ts] export default 0; diff --git a/tests/baselines/reference/moduleSymbolMerging.js b/tests/baselines/reference/moduleSymbolMerging.js index d43fff1378a..9381e47cacf 100644 --- a/tests/baselines/reference/moduleSymbolMerging.js +++ b/tests/baselines/reference/moduleSymbolMerging.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleSymbolMerging.ts] //// //// [A.ts] - module A { export interface I {} } //// [B.ts] diff --git a/tests/baselines/reference/moduleSymbolMerging.symbols b/tests/baselines/reference/moduleSymbolMerging.symbols index 4e8ca8a1526..010f291b9cc 100644 --- a/tests/baselines/reference/moduleSymbolMerging.symbols +++ b/tests/baselines/reference/moduleSymbolMerging.symbols @@ -9,13 +9,12 @@ module B { export function f(): A.I { return null; } >f : Symbol(f, Decl(B.ts, 2, 10)) >A : Symbol(A, Decl(A.ts, 0, 0), Decl(B.ts, 0, 0)) ->I : Symbol(A.I, Decl(A.ts, 1, 10)) +>I : Symbol(A.I, Decl(A.ts, 0, 10)) } === tests/cases/compiler/A.ts === - module A { export interface I {} } >A : Symbol(A, Decl(A.ts, 0, 0), Decl(B.ts, 0, 0)) ->I : Symbol(I, Decl(A.ts, 1, 10)) +>I : Symbol(I, Decl(A.ts, 0, 10)) diff --git a/tests/baselines/reference/moduleSymbolMerging.types b/tests/baselines/reference/moduleSymbolMerging.types index 0f5dfae5c3d..27d2a611a9f 100644 --- a/tests/baselines/reference/moduleSymbolMerging.types +++ b/tests/baselines/reference/moduleSymbolMerging.types @@ -15,7 +15,6 @@ module B { === tests/cases/compiler/A.ts === - module A { export interface I {} } >A : typeof A >I : I diff --git a/tests/baselines/reference/moduleVisibilityTest1.js b/tests/baselines/reference/moduleVisibilityTest1.js index 537ec23b393..1bae7ecfd1f 100644 --- a/tests/baselines/reference/moduleVisibilityTest1.js +++ b/tests/baselines/reference/moduleVisibilityTest1.js @@ -1,6 +1,4 @@ //// [moduleVisibilityTest1.ts] - - module OuterMod { export function someExportedOuterFunc() { return -1; } diff --git a/tests/baselines/reference/moduleVisibilityTest1.symbols b/tests/baselines/reference/moduleVisibilityTest1.symbols index 7c939fee5c3..c9c8dcd3734 100644 --- a/tests/baselines/reference/moduleVisibilityTest1.symbols +++ b/tests/baselines/reference/moduleVisibilityTest1.symbols @@ -1,166 +1,164 @@ === tests/cases/compiler/moduleVisibilityTest1.ts === - - module OuterMod { >OuterMod : Symbol(OuterMod, Decl(moduleVisibilityTest1.ts, 0, 0)) export function someExportedOuterFunc() { return -1; } ->someExportedOuterFunc : Symbol(someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 2, 17)) +>someExportedOuterFunc : Symbol(someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 0, 17)) export module OuterInnerMod { ->OuterInnerMod : Symbol(OuterInnerMod, Decl(moduleVisibilityTest1.ts, 3, 55)) +>OuterInnerMod : Symbol(OuterInnerMod, Decl(moduleVisibilityTest1.ts, 1, 55)) export function someExportedOuterInnerFunc() { return "foo"; } ->someExportedOuterInnerFunc : Symbol(someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 5, 30)) +>someExportedOuterInnerFunc : Symbol(someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 3, 30)) } } import OuterInnerAlias = OuterMod.OuterInnerMod; ->OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 8, 1)) +>OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 6, 1)) >OuterMod : Symbol(OuterMod, Decl(moduleVisibilityTest1.ts, 0, 0)) ->OuterInnerMod : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 3, 55)) +>OuterInnerMod : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 1, 55)) module M { ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) export module InnerMod { ->InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 12, 10)) +>InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 10, 10)) export function someExportedInnerFunc() { return -2; } ->someExportedInnerFunc : Symbol(someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 14, 25)) +>someExportedInnerFunc : Symbol(someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 12, 25)) } export enum E { ->E : Symbol(E, Decl(moduleVisibilityTest1.ts, 16, 2)) +>E : Symbol(E, Decl(moduleVisibilityTest1.ts, 14, 2)) A, ->A : Symbol(E.A, Decl(moduleVisibilityTest1.ts, 18, 16)) +>A : Symbol(E.A, Decl(moduleVisibilityTest1.ts, 16, 16)) B, ->B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 19, 4)) +>B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 17, 4)) C, ->C : Symbol(E.C, Decl(moduleVisibilityTest1.ts, 20, 4)) +>C : Symbol(E.C, Decl(moduleVisibilityTest1.ts, 18, 4)) } export var x = 5; ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) export declare var exported_var; ->exported_var : Symbol(exported_var, Decl(moduleVisibilityTest1.ts, 25, 19)) +>exported_var : Symbol(exported_var, Decl(moduleVisibilityTest1.ts, 23, 19)) var y = x + x; ->y : Symbol(y, Decl(moduleVisibilityTest1.ts, 27, 4)) ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>y : Symbol(y, Decl(moduleVisibilityTest1.ts, 25, 4)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) export interface I { ->I : Symbol(I, Decl(moduleVisibilityTest1.ts, 27, 15)) +>I : Symbol(I, Decl(moduleVisibilityTest1.ts, 25, 15)) someMethod():number; ->someMethod : Symbol(I.someMethod, Decl(moduleVisibilityTest1.ts, 30, 21)) +>someMethod : Symbol(I.someMethod, Decl(moduleVisibilityTest1.ts, 28, 21)) } class B {public b = 0;} ->B : Symbol(B, Decl(moduleVisibilityTest1.ts, 32, 2)) ->b : Symbol(B.b, Decl(moduleVisibilityTest1.ts, 34, 11)) +>B : Symbol(B, Decl(moduleVisibilityTest1.ts, 30, 2)) +>b : Symbol(B.b, Decl(moduleVisibilityTest1.ts, 32, 11)) export class C implements I { ->C : Symbol(C, Decl(moduleVisibilityTest1.ts, 34, 25)) ->I : Symbol(I, Decl(moduleVisibilityTest1.ts, 27, 15)) +>C : Symbol(C, Decl(moduleVisibilityTest1.ts, 32, 25)) +>I : Symbol(I, Decl(moduleVisibilityTest1.ts, 25, 15)) public someMethodThatCallsAnOuterMethod() {return OuterInnerAlias.someExportedOuterInnerFunc();} ->someMethodThatCallsAnOuterMethod : Symbol(C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 36, 31)) ->OuterInnerAlias.someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 5, 30)) ->OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 8, 1)) ->someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 5, 30)) +>someMethodThatCallsAnOuterMethod : Symbol(C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 34, 31)) +>OuterInnerAlias.someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 3, 30)) +>OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 6, 1)) +>someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 3, 30)) public someMethodThatCallsAnInnerMethod() {return InnerMod.someExportedInnerFunc();} ->someMethodThatCallsAnInnerMethod : Symbol(C.someMethodThatCallsAnInnerMethod, Decl(moduleVisibilityTest1.ts, 37, 98)) ->InnerMod.someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 14, 25)) ->InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 12, 10)) ->someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 14, 25)) +>someMethodThatCallsAnInnerMethod : Symbol(C.someMethodThatCallsAnInnerMethod, Decl(moduleVisibilityTest1.ts, 35, 98)) +>InnerMod.someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 12, 25)) +>InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 10, 10)) +>someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 12, 25)) public someMethodThatCallsAnOuterInnerMethod() {return OuterMod.someExportedOuterFunc();} ->someMethodThatCallsAnOuterInnerMethod : Symbol(C.someMethodThatCallsAnOuterInnerMethod, Decl(moduleVisibilityTest1.ts, 38, 86)) ->OuterMod.someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 2, 17)) +>someMethodThatCallsAnOuterInnerMethod : Symbol(C.someMethodThatCallsAnOuterInnerMethod, Decl(moduleVisibilityTest1.ts, 36, 86)) +>OuterMod.someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 0, 17)) >OuterMod : Symbol(OuterMod, Decl(moduleVisibilityTest1.ts, 0, 0)) ->someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 2, 17)) +>someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 0, 17)) public someMethod() { return 0; } ->someMethod : Symbol(C.someMethod, Decl(moduleVisibilityTest1.ts, 39, 91)) +>someMethod : Symbol(C.someMethod, Decl(moduleVisibilityTest1.ts, 37, 91)) public someProp = 1; ->someProp : Symbol(C.someProp, Decl(moduleVisibilityTest1.ts, 40, 35)) +>someProp : Symbol(C.someProp, Decl(moduleVisibilityTest1.ts, 38, 35)) constructor() { function someInnerFunc() { return 2; } ->someInnerFunc : Symbol(someInnerFunc, Decl(moduleVisibilityTest1.ts, 43, 17)) +>someInnerFunc : Symbol(someInnerFunc, Decl(moduleVisibilityTest1.ts, 41, 17)) var someInnerVar = 3; ->someInnerVar : Symbol(someInnerVar, Decl(moduleVisibilityTest1.ts, 45, 15)) +>someInnerVar : Symbol(someInnerVar, Decl(moduleVisibilityTest1.ts, 43, 15)) } } var someModuleVar = 4; ->someModuleVar : Symbol(someModuleVar, Decl(moduleVisibilityTest1.ts, 49, 4)) +>someModuleVar : Symbol(someModuleVar, Decl(moduleVisibilityTest1.ts, 47, 4)) function someModuleFunction() { return 5;} ->someModuleFunction : Symbol(someModuleFunction, Decl(moduleVisibilityTest1.ts, 49, 23)) +>someModuleFunction : Symbol(someModuleFunction, Decl(moduleVisibilityTest1.ts, 47, 23)) } module M { ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) export var c = x; ->c : Symbol(c, Decl(moduleVisibilityTest1.ts, 55, 11)) ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>c : Symbol(c, Decl(moduleVisibilityTest1.ts, 53, 11)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) export var meb = M.E.B; ->meb : Symbol(meb, Decl(moduleVisibilityTest1.ts, 56, 11)) ->M.E.B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 19, 4)) ->M.E : Symbol(E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->E : Symbol(E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 19, 4)) +>meb : Symbol(meb, Decl(moduleVisibilityTest1.ts, 54, 11)) +>M.E.B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 17, 4)) +>M.E : Symbol(E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>E : Symbol(E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 17, 4)) } var cprime : M.I = null; ->cprime : Symbol(cprime, Decl(moduleVisibilityTest1.ts, 59, 3)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 27, 15)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 27, 15)) +>cprime : Symbol(cprime, Decl(moduleVisibilityTest1.ts, 57, 3)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 25, 15)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 25, 15)) var c = new M.C(); ->c : Symbol(c, Decl(moduleVisibilityTest1.ts, 61, 3)) ->M.C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 34, 25)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 34, 25)) +>c : Symbol(c, Decl(moduleVisibilityTest1.ts, 59, 3)) +>M.C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 32, 25)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 32, 25)) var z = M.x; ->z : Symbol(z, Decl(moduleVisibilityTest1.ts, 62, 3)) ->M.x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 24, 11)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>z : Symbol(z, Decl(moduleVisibilityTest1.ts, 60, 3)) +>M.x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 22, 11)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 22, 11)) var alpha = M.E.A; ->alpha : Symbol(alpha, Decl(moduleVisibilityTest1.ts, 63, 3)) ->M.E.A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 18, 16)) ->M.E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 18, 16)) +>alpha : Symbol(alpha, Decl(moduleVisibilityTest1.ts, 61, 3)) +>M.E.A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 16, 16)) +>M.E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 16, 16)) var omega = M.exported_var; ->omega : Symbol(omega, Decl(moduleVisibilityTest1.ts, 64, 3)) ->M.exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 25, 19)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 25, 19)) +>omega : Symbol(omega, Decl(moduleVisibilityTest1.ts, 62, 3)) +>M.exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 23, 19)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 23, 19)) c.someMethodThatCallsAnOuterMethod(); ->c.someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 36, 31)) ->c : Symbol(c, Decl(moduleVisibilityTest1.ts, 61, 3)) ->someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 36, 31)) +>c.someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 34, 31)) +>c : Symbol(c, Decl(moduleVisibilityTest1.ts, 59, 3)) +>someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 34, 31)) diff --git a/tests/baselines/reference/moduleVisibilityTest1.types b/tests/baselines/reference/moduleVisibilityTest1.types index c8b7a1a8e31..e2171eb6e59 100644 --- a/tests/baselines/reference/moduleVisibilityTest1.types +++ b/tests/baselines/reference/moduleVisibilityTest1.types @@ -1,6 +1,4 @@ === tests/cases/compiler/moduleVisibilityTest1.ts === - - module OuterMod { >OuterMod : typeof OuterMod diff --git a/tests/baselines/reference/moduleVisibilityTest2.errors.txt b/tests/baselines/reference/moduleVisibilityTest2.errors.txt index d7b991f9f62..2b5686124b8 100644 --- a/tests/baselines/reference/moduleVisibilityTest2.errors.txt +++ b/tests/baselines/reference/moduleVisibilityTest2.errors.txt @@ -1,14 +1,12 @@ -tests/cases/compiler/moduleVisibilityTest2.ts(57,17): error TS2304: Cannot find name 'x'. -tests/cases/compiler/moduleVisibilityTest2.ts(58,21): error TS2339: Property 'E' does not exist on type 'typeof M'. -tests/cases/compiler/moduleVisibilityTest2.ts(61,16): error TS2694: Namespace 'M' has no exported member 'I'. -tests/cases/compiler/moduleVisibilityTest2.ts(61,23): error TS2694: Namespace 'M' has no exported member 'I'. -tests/cases/compiler/moduleVisibilityTest2.ts(64,11): error TS2339: Property 'x' does not exist on type 'typeof M'. -tests/cases/compiler/moduleVisibilityTest2.ts(65,15): error TS2339: Property 'E' does not exist on type 'typeof M'. +tests/cases/compiler/moduleVisibilityTest2.ts(55,17): error TS2304: Cannot find name 'x'. +tests/cases/compiler/moduleVisibilityTest2.ts(56,21): error TS2339: Property 'E' does not exist on type 'typeof M'. +tests/cases/compiler/moduleVisibilityTest2.ts(59,16): error TS2694: Namespace 'M' has no exported member 'I'. +tests/cases/compiler/moduleVisibilityTest2.ts(59,23): error TS2694: Namespace 'M' has no exported member 'I'. +tests/cases/compiler/moduleVisibilityTest2.ts(62,11): error TS2339: Property 'x' does not exist on type 'typeof M'. +tests/cases/compiler/moduleVisibilityTest2.ts(63,15): error TS2339: Property 'E' does not exist on type 'typeof M'. ==== tests/cases/compiler/moduleVisibilityTest2.ts (6 errors) ==== - - module OuterMod { export function someExportedOuterFunc() { return -1; } diff --git a/tests/baselines/reference/moduleVisibilityTest2.js b/tests/baselines/reference/moduleVisibilityTest2.js index 62b12b87808..b40d1721b65 100644 --- a/tests/baselines/reference/moduleVisibilityTest2.js +++ b/tests/baselines/reference/moduleVisibilityTest2.js @@ -1,6 +1,4 @@ //// [moduleVisibilityTest2.ts] - - module OuterMod { export function someExportedOuterFunc() { return -1; } diff --git a/tests/baselines/reference/moduledecl.js b/tests/baselines/reference/moduledecl.js index 437907017fc..b2dd3caaf35 100644 --- a/tests/baselines/reference/moduledecl.js +++ b/tests/baselines/reference/moduledecl.js @@ -1,5 +1,4 @@ //// [moduledecl.ts] - module a { } diff --git a/tests/baselines/reference/moduledecl.symbols b/tests/baselines/reference/moduledecl.symbols index f0b2db9121c..2fd96aee321 100644 --- a/tests/baselines/reference/moduledecl.symbols +++ b/tests/baselines/reference/moduledecl.symbols @@ -1,271 +1,270 @@ === tests/cases/compiler/moduledecl.ts === - module a { >a : Symbol(a, Decl(moduledecl.ts, 0, 0)) } module b.a { ->b : Symbol(b, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(a, Decl(moduledecl.ts, 4, 9)) +>b : Symbol(b, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(a, Decl(moduledecl.ts, 3, 9)) } module c.a.b { ->c : Symbol(c, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(a, Decl(moduledecl.ts, 7, 9)) ->b : Symbol(ma.b, Decl(moduledecl.ts, 7, 11)) +>c : Symbol(c, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(a, Decl(moduledecl.ts, 6, 9)) +>b : Symbol(ma.b, Decl(moduledecl.ts, 6, 11)) import ma = a; ->ma : Symbol(ma, Decl(moduledecl.ts, 7, 14)) ->a : Symbol(ma, Decl(moduledecl.ts, 7, 9)) +>ma : Symbol(ma, Decl(moduledecl.ts, 6, 14)) +>a : Symbol(ma, Decl(moduledecl.ts, 6, 9)) } module mImport { ->mImport : Symbol(mImport, Decl(moduledecl.ts, 9, 1)) +>mImport : Symbol(mImport, Decl(moduledecl.ts, 8, 1)) import d = a; ->d : Symbol(d, Decl(moduledecl.ts, 11, 16)) +>d : Symbol(d, Decl(moduledecl.ts, 10, 16)) >a : Symbol(d, Decl(moduledecl.ts, 0, 0)) import e = b.a; ->e : Symbol(e, Decl(moduledecl.ts, 12, 17)) ->b : Symbol(b, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(e, Decl(moduledecl.ts, 4, 9)) +>e : Symbol(e, Decl(moduledecl.ts, 11, 17)) +>b : Symbol(b, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(e, Decl(moduledecl.ts, 3, 9)) import d1 = a; ->d1 : Symbol(d1, Decl(moduledecl.ts, 13, 19)) +>d1 : Symbol(d1, Decl(moduledecl.ts, 12, 19)) >a : Symbol(d, Decl(moduledecl.ts, 0, 0)) import e1 = b.a; ->e1 : Symbol(e1, Decl(moduledecl.ts, 14, 18)) ->b : Symbol(b, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(e, Decl(moduledecl.ts, 4, 9)) +>e1 : Symbol(e1, Decl(moduledecl.ts, 13, 18)) +>b : Symbol(b, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(e, Decl(moduledecl.ts, 3, 9)) } module m0 { ->m0 : Symbol(m0, Decl(moduledecl.ts, 16, 1)) +>m0 : Symbol(m0, Decl(moduledecl.ts, 15, 1)) function f1() { ->f1 : Symbol(f1, Decl(moduledecl.ts, 18, 11)) +>f1 : Symbol(f1, Decl(moduledecl.ts, 17, 11)) } function f2(s: string); ->f2 : Symbol(f2, Decl(moduledecl.ts, 20, 5), Decl(moduledecl.ts, 22, 27), Decl(moduledecl.ts, 23, 27)) ->s : Symbol(s, Decl(moduledecl.ts, 22, 16)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 19, 5), Decl(moduledecl.ts, 21, 27), Decl(moduledecl.ts, 22, 27)) +>s : Symbol(s, Decl(moduledecl.ts, 21, 16)) function f2(n: number); ->f2 : Symbol(f2, Decl(moduledecl.ts, 20, 5), Decl(moduledecl.ts, 22, 27), Decl(moduledecl.ts, 23, 27)) ->n : Symbol(n, Decl(moduledecl.ts, 23, 16)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 19, 5), Decl(moduledecl.ts, 21, 27), Decl(moduledecl.ts, 22, 27)) +>n : Symbol(n, Decl(moduledecl.ts, 22, 16)) function f2(ns: any) { ->f2 : Symbol(f2, Decl(moduledecl.ts, 20, 5), Decl(moduledecl.ts, 22, 27), Decl(moduledecl.ts, 23, 27)) ->ns : Symbol(ns, Decl(moduledecl.ts, 24, 16)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 19, 5), Decl(moduledecl.ts, 21, 27), Decl(moduledecl.ts, 22, 27)) +>ns : Symbol(ns, Decl(moduledecl.ts, 23, 16)) } class c1 { ->c1 : Symbol(c1, Decl(moduledecl.ts, 25, 5)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 24, 5)) public a : ()=>string; ->a : Symbol(c1.a, Decl(moduledecl.ts, 27, 14)) +>a : Symbol(c1.a, Decl(moduledecl.ts, 26, 14)) private b: ()=>number; ->b : Symbol(c1.b, Decl(moduledecl.ts, 28, 30)) +>b : Symbol(c1.b, Decl(moduledecl.ts, 27, 30)) private static s1; ->s1 : Symbol(c1.s1, Decl(moduledecl.ts, 29, 30)) +>s1 : Symbol(c1.s1, Decl(moduledecl.ts, 28, 30)) public static s2; ->s2 : Symbol(c1.s2, Decl(moduledecl.ts, 30, 26)) +>s2 : Symbol(c1.s2, Decl(moduledecl.ts, 29, 26)) } interface i1 { ->i1 : Symbol(i1, Decl(moduledecl.ts, 32, 5)) +>i1 : Symbol(i1, Decl(moduledecl.ts, 31, 5)) () : Object; >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [n: number]: c1; ->n : Symbol(n, Decl(moduledecl.ts, 36, 9)) ->c1 : Symbol(c1, Decl(moduledecl.ts, 25, 5)) +>n : Symbol(n, Decl(moduledecl.ts, 35, 9)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 24, 5)) } import m2 = a; ->m2 : Symbol(m2, Decl(moduledecl.ts, 37, 5)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 36, 5)) >a : Symbol(m2, Decl(moduledecl.ts, 0, 0)) import m3 = b; ->m3 : Symbol(m3, Decl(moduledecl.ts, 39, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 38, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) import m4 = b.a; ->m4 : Symbol(m4, Decl(moduledecl.ts, 40, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(m3.a, Decl(moduledecl.ts, 4, 9)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 39, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(m3.a, Decl(moduledecl.ts, 3, 9)) import m5 = c; ->m5 : Symbol(m5, Decl(moduledecl.ts, 41, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 40, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) import m6 = c.a; ->m6 : Symbol(m6, Decl(moduledecl.ts, 42, 18)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) +>m6 : Symbol(m6, Decl(moduledecl.ts, 41, 18)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) import m7 = c.a.b; ->m7 : Symbol(m7, Decl(moduledecl.ts, 43, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) ->b : Symbol(m6.b, Decl(moduledecl.ts, 7, 11)) +>m7 : Symbol(m7, Decl(moduledecl.ts, 42, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) +>b : Symbol(m6.b, Decl(moduledecl.ts, 6, 11)) } module m1 { ->m1 : Symbol(m1, Decl(moduledecl.ts, 45, 1)) +>m1 : Symbol(m1, Decl(moduledecl.ts, 44, 1)) export function f1() { ->f1 : Symbol(f1, Decl(moduledecl.ts, 47, 11)) +>f1 : Symbol(f1, Decl(moduledecl.ts, 46, 11)) } export function f2(s: string); ->f2 : Symbol(f2, Decl(moduledecl.ts, 49, 5), Decl(moduledecl.ts, 51, 34), Decl(moduledecl.ts, 52, 34)) ->s : Symbol(s, Decl(moduledecl.ts, 51, 23)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 48, 5), Decl(moduledecl.ts, 50, 34), Decl(moduledecl.ts, 51, 34)) +>s : Symbol(s, Decl(moduledecl.ts, 50, 23)) export function f2(n: number); ->f2 : Symbol(f2, Decl(moduledecl.ts, 49, 5), Decl(moduledecl.ts, 51, 34), Decl(moduledecl.ts, 52, 34)) ->n : Symbol(n, Decl(moduledecl.ts, 52, 23)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 48, 5), Decl(moduledecl.ts, 50, 34), Decl(moduledecl.ts, 51, 34)) +>n : Symbol(n, Decl(moduledecl.ts, 51, 23)) export function f2(ns: any) { ->f2 : Symbol(f2, Decl(moduledecl.ts, 49, 5), Decl(moduledecl.ts, 51, 34), Decl(moduledecl.ts, 52, 34)) ->ns : Symbol(ns, Decl(moduledecl.ts, 53, 23)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 48, 5), Decl(moduledecl.ts, 50, 34), Decl(moduledecl.ts, 51, 34)) +>ns : Symbol(ns, Decl(moduledecl.ts, 52, 23)) } export class c1 { ->c1 : Symbol(c1, Decl(moduledecl.ts, 54, 5)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 53, 5)) public a: () =>string; ->a : Symbol(c1.a, Decl(moduledecl.ts, 56, 21)) +>a : Symbol(c1.a, Decl(moduledecl.ts, 55, 21)) private b: () =>number; ->b : Symbol(c1.b, Decl(moduledecl.ts, 57, 30)) +>b : Symbol(c1.b, Decl(moduledecl.ts, 56, 30)) private static s1; ->s1 : Symbol(c1.s1, Decl(moduledecl.ts, 58, 31)) +>s1 : Symbol(c1.s1, Decl(moduledecl.ts, 57, 31)) public static s2; ->s2 : Symbol(c1.s2, Decl(moduledecl.ts, 59, 26)) +>s2 : Symbol(c1.s2, Decl(moduledecl.ts, 58, 26)) public d() { ->d : Symbol(c1.d, Decl(moduledecl.ts, 60, 25)) +>d : Symbol(c1.d, Decl(moduledecl.ts, 59, 25)) return "Hello"; } public e: { x: number; y: string; }; ->e : Symbol(c1.e, Decl(moduledecl.ts, 64, 9)) ->x : Symbol(x, Decl(moduledecl.ts, 66, 19)) ->y : Symbol(y, Decl(moduledecl.ts, 66, 30)) +>e : Symbol(c1.e, Decl(moduledecl.ts, 63, 9)) +>x : Symbol(x, Decl(moduledecl.ts, 65, 19)) +>y : Symbol(y, Decl(moduledecl.ts, 65, 30)) constructor (public n, public n2: number, private n3, private n4: string) { ->n : Symbol(c1.n, Decl(moduledecl.ts, 67, 21)) ->n2 : Symbol(c1.n2, Decl(moduledecl.ts, 67, 30)) ->n3 : Symbol(c1.n3, Decl(moduledecl.ts, 67, 49)) ->n4 : Symbol(c1.n4, Decl(moduledecl.ts, 67, 61)) +>n : Symbol(c1.n, Decl(moduledecl.ts, 66, 21)) +>n2 : Symbol(c1.n2, Decl(moduledecl.ts, 66, 30)) +>n3 : Symbol(c1.n3, Decl(moduledecl.ts, 66, 49)) +>n4 : Symbol(c1.n4, Decl(moduledecl.ts, 66, 61)) } } export interface i1 { ->i1 : Symbol(i1, Decl(moduledecl.ts, 69, 5)) +>i1 : Symbol(i1, Decl(moduledecl.ts, 68, 5)) () : Object; >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [n: number]: c1; ->n : Symbol(n, Decl(moduledecl.ts, 73, 9)) ->c1 : Symbol(c1, Decl(moduledecl.ts, 54, 5)) +>n : Symbol(n, Decl(moduledecl.ts, 72, 9)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 53, 5)) } import m2 = a; ->m2 : Symbol(m2, Decl(moduledecl.ts, 74, 5)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 73, 5)) >a : Symbol(m2, Decl(moduledecl.ts, 0, 0)) import m3 = b; ->m3 : Symbol(m3, Decl(moduledecl.ts, 76, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 75, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) import m4 = b.a; ->m4 : Symbol(m4, Decl(moduledecl.ts, 77, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(m3.a, Decl(moduledecl.ts, 4, 9)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 76, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(m3.a, Decl(moduledecl.ts, 3, 9)) import m5 = c; ->m5 : Symbol(m5, Decl(moduledecl.ts, 78, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 77, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) import m6 = c.a; ->m6 : Symbol(m6, Decl(moduledecl.ts, 79, 18)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) +>m6 : Symbol(m6, Decl(moduledecl.ts, 78, 18)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) import m7 = c.a.b; ->m7 : Symbol(m7, Decl(moduledecl.ts, 80, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) ->b : Symbol(m6.b, Decl(moduledecl.ts, 7, 11)) +>m7 : Symbol(m7, Decl(moduledecl.ts, 79, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) +>b : Symbol(m6.b, Decl(moduledecl.ts, 6, 11)) } module m { ->m : Symbol(m, Decl(moduledecl.ts, 82, 1), Decl(moduledecl.ts, 93, 1)) +>m : Symbol(m, Decl(moduledecl.ts, 81, 1), Decl(moduledecl.ts, 92, 1)) export module m2 { ->m2 : Symbol(m2, Decl(moduledecl.ts, 84, 10)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 83, 10)) var a = 10; ->a : Symbol(a, Decl(moduledecl.ts, 86, 11)) +>a : Symbol(a, Decl(moduledecl.ts, 85, 11)) export var b: number; ->b : Symbol(b, Decl(moduledecl.ts, 87, 18)) +>b : Symbol(b, Decl(moduledecl.ts, 86, 18)) } export module m3 { ->m3 : Symbol(m3, Decl(moduledecl.ts, 88, 5)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 87, 5)) export var c: number; ->c : Symbol(c, Decl(moduledecl.ts, 91, 18)) +>c : Symbol(c, Decl(moduledecl.ts, 90, 18)) } } module m { ->m : Symbol(m, Decl(moduledecl.ts, 82, 1), Decl(moduledecl.ts, 93, 1)) +>m : Symbol(m, Decl(moduledecl.ts, 81, 1), Decl(moduledecl.ts, 92, 1)) export module m25 { ->m25 : Symbol(m25, Decl(moduledecl.ts, 95, 10)) +>m25 : Symbol(m25, Decl(moduledecl.ts, 94, 10)) export module m5 { ->m5 : Symbol(m5, Decl(moduledecl.ts, 97, 23)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 96, 23)) export var c: number; ->c : Symbol(c, Decl(moduledecl.ts, 99, 22)) +>c : Symbol(c, Decl(moduledecl.ts, 98, 22)) } } } module m13 { ->m13 : Symbol(m13, Decl(moduledecl.ts, 102, 1)) +>m13 : Symbol(m13, Decl(moduledecl.ts, 101, 1)) export module m4 { ->m4 : Symbol(m4, Decl(moduledecl.ts, 104, 12)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 103, 12)) export module m2 { ->m2 : Symbol(m2, Decl(moduledecl.ts, 105, 22)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 104, 22)) export module m3 { ->m3 : Symbol(m3, Decl(moduledecl.ts, 106, 26)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 105, 26)) export var c: number; ->c : Symbol(c, Decl(moduledecl.ts, 108, 26)) +>c : Symbol(c, Decl(moduledecl.ts, 107, 26)) } } export function f() { ->f : Symbol(f, Decl(moduledecl.ts, 110, 9)) +>f : Symbol(f, Decl(moduledecl.ts, 109, 9)) return 20; } @@ -273,264 +272,264 @@ module m13 { } declare module m4 { ->m4 : Symbol(m4, Decl(moduledecl.ts, 116, 1)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 115, 1)) export var b; ->b : Symbol(b, Decl(moduledecl.ts, 119, 14)) +>b : Symbol(b, Decl(moduledecl.ts, 118, 14)) } declare module m5 { ->m5 : Symbol(m5, Decl(moduledecl.ts, 120, 1)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 119, 1)) export var c; ->c : Symbol(c, Decl(moduledecl.ts, 123, 14)) +>c : Symbol(c, Decl(moduledecl.ts, 122, 14)) } declare module m43 { ->m43 : Symbol(m43, Decl(moduledecl.ts, 124, 1)) +>m43 : Symbol(m43, Decl(moduledecl.ts, 123, 1)) export var b; ->b : Symbol(b, Decl(moduledecl.ts, 127, 14)) +>b : Symbol(b, Decl(moduledecl.ts, 126, 14)) } declare module m55 { ->m55 : Symbol(m55, Decl(moduledecl.ts, 128, 1)) +>m55 : Symbol(m55, Decl(moduledecl.ts, 127, 1)) export var c; ->c : Symbol(c, Decl(moduledecl.ts, 131, 14)) +>c : Symbol(c, Decl(moduledecl.ts, 130, 14)) } declare module "m3" { export var b: number; ->b : Symbol(b, Decl(moduledecl.ts, 135, 14)) +>b : Symbol(b, Decl(moduledecl.ts, 134, 14)) } module exportTests { ->exportTests : Symbol(exportTests, Decl(moduledecl.ts, 136, 1)) +>exportTests : Symbol(exportTests, Decl(moduledecl.ts, 135, 1)) export class C1_public { ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) private f2() { ->f2 : Symbol(C1_public.f2, Decl(moduledecl.ts, 139, 28)) +>f2 : Symbol(C1_public.f2, Decl(moduledecl.ts, 138, 28)) return 30; } public f3() { ->f3 : Symbol(C1_public.f3, Decl(moduledecl.ts, 142, 9)) +>f3 : Symbol(C1_public.f3, Decl(moduledecl.ts, 141, 9)) return "string"; } } class C2_private { ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) private f2() { ->f2 : Symbol(C2_private.f2, Decl(moduledecl.ts, 148, 22)) +>f2 : Symbol(C2_private.f2, Decl(moduledecl.ts, 147, 22)) return 30; } public f3() { ->f3 : Symbol(C2_private.f3, Decl(moduledecl.ts, 151, 9)) +>f3 : Symbol(C2_private.f3, Decl(moduledecl.ts, 150, 9)) return "string"; } } export class C3_public { ->C3_public : Symbol(C3_public, Decl(moduledecl.ts, 156, 5)) +>C3_public : Symbol(C3_public, Decl(moduledecl.ts, 155, 5)) private getC2_private() { ->getC2_private : Symbol(C3_public.getC2_private, Decl(moduledecl.ts, 158, 28)) +>getC2_private : Symbol(C3_public.getC2_private, Decl(moduledecl.ts, 157, 28)) return new C2_private(); ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) } private setC2_private(arg: C2_private) { ->setC2_private : Symbol(C3_public.setC2_private, Decl(moduledecl.ts, 161, 9)) ->arg : Symbol(arg, Decl(moduledecl.ts, 162, 30)) ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>setC2_private : Symbol(C3_public.setC2_private, Decl(moduledecl.ts, 160, 9)) +>arg : Symbol(arg, Decl(moduledecl.ts, 161, 30)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) } private get c2() { ->c2 : Symbol(C3_public.c2, Decl(moduledecl.ts, 163, 9)) +>c2 : Symbol(C3_public.c2, Decl(moduledecl.ts, 162, 9)) return new C2_private(); ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) } public getC1_public() { ->getC1_public : Symbol(C3_public.getC1_public, Decl(moduledecl.ts, 166, 9)) +>getC1_public : Symbol(C3_public.getC1_public, Decl(moduledecl.ts, 165, 9)) return new C1_public(); ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) } public setC1_public(arg: C1_public) { ->setC1_public : Symbol(C3_public.setC1_public, Decl(moduledecl.ts, 169, 9)) ->arg : Symbol(arg, Decl(moduledecl.ts, 170, 28)) ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>setC1_public : Symbol(C3_public.setC1_public, Decl(moduledecl.ts, 168, 9)) +>arg : Symbol(arg, Decl(moduledecl.ts, 169, 28)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) } public get c1() { ->c1 : Symbol(C3_public.c1, Decl(moduledecl.ts, 171, 9)) +>c1 : Symbol(C3_public.c1, Decl(moduledecl.ts, 170, 9)) return new C1_public(); ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) } } } declare module mAmbient { ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) class C { ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) public myProp: number; ->myProp : Symbol(C.myProp, Decl(moduledecl.ts, 179, 13)) +>myProp : Symbol(C.myProp, Decl(moduledecl.ts, 178, 13)) } function foo() : C; ->foo : Symbol(foo, Decl(moduledecl.ts, 181, 5)) ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>foo : Symbol(foo, Decl(moduledecl.ts, 180, 5)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) var aVar: C; ->aVar : Symbol(aVar, Decl(moduledecl.ts, 184, 7)) ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>aVar : Symbol(aVar, Decl(moduledecl.ts, 183, 7)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) interface B { ->B : Symbol(B, Decl(moduledecl.ts, 184, 16)) +>B : Symbol(B, Decl(moduledecl.ts, 183, 16)) x: number; ->x : Symbol(B.x, Decl(moduledecl.ts, 185, 17)) +>x : Symbol(B.x, Decl(moduledecl.ts, 184, 17)) y: C; ->y : Symbol(B.y, Decl(moduledecl.ts, 186, 18)) ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>y : Symbol(B.y, Decl(moduledecl.ts, 185, 18)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) } enum e { ->e : Symbol(e, Decl(moduledecl.ts, 188, 5)) +>e : Symbol(e, Decl(moduledecl.ts, 187, 5)) x, ->x : Symbol(e.x, Decl(moduledecl.ts, 189, 12)) +>x : Symbol(e.x, Decl(moduledecl.ts, 188, 12)) y, ->y : Symbol(e.y, Decl(moduledecl.ts, 190, 10)) +>y : Symbol(e.y, Decl(moduledecl.ts, 189, 10)) z ->z : Symbol(e.z, Decl(moduledecl.ts, 191, 10)) +>z : Symbol(e.z, Decl(moduledecl.ts, 190, 10)) } module m3 { ->m3 : Symbol(m3, Decl(moduledecl.ts, 193, 5)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 192, 5)) class C { ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) public myProp: number; ->myProp : Symbol(C.myProp, Decl(moduledecl.ts, 196, 17)) +>myProp : Symbol(C.myProp, Decl(moduledecl.ts, 195, 17)) } function foo(): C; ->foo : Symbol(foo, Decl(moduledecl.ts, 198, 9)) ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>foo : Symbol(foo, Decl(moduledecl.ts, 197, 9)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) var aVar: C; ->aVar : Symbol(aVar, Decl(moduledecl.ts, 201, 11)) ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>aVar : Symbol(aVar, Decl(moduledecl.ts, 200, 11)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) interface B { ->B : Symbol(B, Decl(moduledecl.ts, 201, 20)) +>B : Symbol(B, Decl(moduledecl.ts, 200, 20)) x: number; ->x : Symbol(B.x, Decl(moduledecl.ts, 202, 21)) +>x : Symbol(B.x, Decl(moduledecl.ts, 201, 21)) y: C; ->y : Symbol(B.y, Decl(moduledecl.ts, 203, 22)) ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>y : Symbol(B.y, Decl(moduledecl.ts, 202, 22)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) } enum e { ->e : Symbol(e, Decl(moduledecl.ts, 205, 9)) +>e : Symbol(e, Decl(moduledecl.ts, 204, 9)) x, ->x : Symbol(e.x, Decl(moduledecl.ts, 206, 16)) +>x : Symbol(e.x, Decl(moduledecl.ts, 205, 16)) y, ->y : Symbol(e.y, Decl(moduledecl.ts, 207, 14)) +>y : Symbol(e.y, Decl(moduledecl.ts, 206, 14)) z ->z : Symbol(e.z, Decl(moduledecl.ts, 208, 14)) +>z : Symbol(e.z, Decl(moduledecl.ts, 207, 14)) } } } function foo() { ->foo : Symbol(foo, Decl(moduledecl.ts, 212, 1)) +>foo : Symbol(foo, Decl(moduledecl.ts, 211, 1)) return mAmbient.foo(); ->mAmbient.foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 181, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 181, 5)) +>mAmbient.foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 180, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 180, 5)) } var cVar = new mAmbient.C(); ->cVar : Symbol(cVar, Decl(moduledecl.ts, 218, 3)) ->mAmbient.C : Symbol(mAmbient.C, Decl(moduledecl.ts, 178, 25)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->C : Symbol(mAmbient.C, Decl(moduledecl.ts, 178, 25)) +>cVar : Symbol(cVar, Decl(moduledecl.ts, 217, 3)) +>mAmbient.C : Symbol(mAmbient.C, Decl(moduledecl.ts, 177, 25)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>C : Symbol(mAmbient.C, Decl(moduledecl.ts, 177, 25)) var aVar = mAmbient.aVar; ->aVar : Symbol(aVar, Decl(moduledecl.ts, 219, 3)) ->mAmbient.aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 184, 7)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 184, 7)) +>aVar : Symbol(aVar, Decl(moduledecl.ts, 218, 3)) +>mAmbient.aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 183, 7)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 183, 7)) var bB: mAmbient.B; ->bB : Symbol(bB, Decl(moduledecl.ts, 220, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->B : Symbol(mAmbient.B, Decl(moduledecl.ts, 184, 16)) +>bB : Symbol(bB, Decl(moduledecl.ts, 219, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>B : Symbol(mAmbient.B, Decl(moduledecl.ts, 183, 16)) var eVar: mAmbient.e; ->eVar : Symbol(eVar, Decl(moduledecl.ts, 221, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->e : Symbol(mAmbient.e, Decl(moduledecl.ts, 188, 5)) +>eVar : Symbol(eVar, Decl(moduledecl.ts, 220, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>e : Symbol(mAmbient.e, Decl(moduledecl.ts, 187, 5)) function m3foo() { ->m3foo : Symbol(m3foo, Decl(moduledecl.ts, 221, 21)) +>m3foo : Symbol(m3foo, Decl(moduledecl.ts, 220, 21)) return mAmbient.m3.foo(); ->mAmbient.m3.foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 198, 9)) ->mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 198, 9)) +>mAmbient.m3.foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 197, 9)) +>mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 197, 9)) } var m3cVar = new mAmbient.m3.C(); ->m3cVar : Symbol(m3cVar, Decl(moduledecl.ts, 227, 3)) ->mAmbient.m3.C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 195, 15)) ->mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 195, 15)) +>m3cVar : Symbol(m3cVar, Decl(moduledecl.ts, 226, 3)) +>mAmbient.m3.C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 194, 15)) +>mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 194, 15)) var m3aVar = mAmbient.m3.aVar; ->m3aVar : Symbol(m3aVar, Decl(moduledecl.ts, 228, 3)) ->mAmbient.m3.aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 201, 11)) ->mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 201, 11)) +>m3aVar : Symbol(m3aVar, Decl(moduledecl.ts, 227, 3)) +>mAmbient.m3.aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 200, 11)) +>mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 200, 11)) var m3bB: mAmbient.m3.B; ->m3bB : Symbol(m3bB, Decl(moduledecl.ts, 229, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->B : Symbol(mAmbient.m3.B, Decl(moduledecl.ts, 201, 20)) +>m3bB : Symbol(m3bB, Decl(moduledecl.ts, 228, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>B : Symbol(mAmbient.m3.B, Decl(moduledecl.ts, 200, 20)) var m3eVar: mAmbient.m3.e; ->m3eVar : Symbol(m3eVar, Decl(moduledecl.ts, 230, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->e : Symbol(mAmbient.m3.e, Decl(moduledecl.ts, 205, 9)) +>m3eVar : Symbol(m3eVar, Decl(moduledecl.ts, 229, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>e : Symbol(mAmbient.m3.e, Decl(moduledecl.ts, 204, 9)) diff --git a/tests/baselines/reference/moduledecl.types b/tests/baselines/reference/moduledecl.types index e6382861972..4dfd012356f 100644 --- a/tests/baselines/reference/moduledecl.types +++ b/tests/baselines/reference/moduledecl.types @@ -1,5 +1,4 @@ === tests/cases/compiler/moduledecl.ts === - module a { >a : any } diff --git a/tests/baselines/reference/multipleDefaultExports01.errors.txt b/tests/baselines/reference/multipleDefaultExports01.errors.txt index 16aa3b2f7b1..b53d4113ded 100644 --- a/tests/baselines/reference/multipleDefaultExports01.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports01.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2528: A module cannot have multiple default exports. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2528: A module cannot have multiple default exports. -tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/m1.ts(1,22): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/m1.ts(5,25): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/m1.ts(10,1): error TS2528: A module cannot have multiple default exports. tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typeof foo' is not callable. Did you mean to include 'new'? ==== tests/cases/conformance/es6/modules/m1.ts (3 errors) ==== - export default class foo { ~~~ !!! error TS2528: A module cannot have multiple default exports. diff --git a/tests/baselines/reference/multipleDefaultExports01.js b/tests/baselines/reference/multipleDefaultExports01.js index 98c17051809..06e53505451 100644 --- a/tests/baselines/reference/multipleDefaultExports01.js +++ b/tests/baselines/reference/multipleDefaultExports01.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/multipleDefaultExports01.ts] //// //// [m1.ts] - export default class foo { } diff --git a/tests/baselines/reference/multipleDefaultExports02.errors.txt b/tests/baselines/reference/multipleDefaultExports02.errors.txt index 3f27db47c94..97a36e06455 100644 --- a/tests/baselines/reference/multipleDefaultExports02.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports02.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2393: Duplicate function implementation. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/m1.ts(1,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/m1.ts(1,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/m1.ts(5,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/m1.ts(5,25): error TS2393: Duplicate function implementation. ==== tests/cases/conformance/es6/modules/m1.ts (4 errors) ==== - export default function foo() { ~~~ !!! error TS2323: Cannot redeclare exported variable 'default'. diff --git a/tests/baselines/reference/multipleDefaultExports02.js b/tests/baselines/reference/multipleDefaultExports02.js index b129dba0392..e2827120da2 100644 --- a/tests/baselines/reference/multipleDefaultExports02.js +++ b/tests/baselines/reference/multipleDefaultExports02.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/multipleDefaultExports02.ts] //// //// [m1.ts] - export default function foo() { } diff --git a/tests/baselines/reference/multipleDefaultExports03.errors.txt b/tests/baselines/reference/multipleDefaultExports03.errors.txt index 5c4b075b009..5b4fc84070b 100644 --- a/tests/baselines/reference/multipleDefaultExports03.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports03.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(2,22): error TS2528: A module cannot have multiple default exports. -tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(5,22): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(1,22): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(4,22): error TS2528: A module cannot have multiple default exports. ==== tests/cases/conformance/es6/modules/multipleDefaultExports03.ts (2 errors) ==== - export default class C { ~ !!! error TS2528: A module cannot have multiple default exports. diff --git a/tests/baselines/reference/multipleDefaultExports03.js b/tests/baselines/reference/multipleDefaultExports03.js index 897a3f00eb4..3b02dd523d7 100644 --- a/tests/baselines/reference/multipleDefaultExports03.js +++ b/tests/baselines/reference/multipleDefaultExports03.js @@ -1,5 +1,4 @@ //// [multipleDefaultExports03.ts] - export default class C { } diff --git a/tests/baselines/reference/multipleDefaultExports04.errors.txt b/tests/baselines/reference/multipleDefaultExports04.errors.txt index bf137e3cc17..2b40316252d 100644 --- a/tests/baselines/reference/multipleDefaultExports04.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports04.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2393: Duplicate function implementation. -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(1,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(1,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(4,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(4,25): error TS2393: Duplicate function implementation. ==== tests/cases/conformance/es6/modules/multipleDefaultExports04.ts (4 errors) ==== - export default function f() { ~ !!! error TS2323: Cannot redeclare exported variable 'default'. diff --git a/tests/baselines/reference/multipleDefaultExports04.js b/tests/baselines/reference/multipleDefaultExports04.js index 341f6f41c62..b488bae33ef 100644 --- a/tests/baselines/reference/multipleDefaultExports04.js +++ b/tests/baselines/reference/multipleDefaultExports04.js @@ -1,5 +1,4 @@ //// [multipleDefaultExports04.ts] - export default function f() { } diff --git a/tests/baselines/reference/multipleExports.errors.txt b/tests/baselines/reference/multipleExports.errors.txt index 43e9c4bffa3..df422fb9d6f 100644 --- a/tests/baselines/reference/multipleExports.errors.txt +++ b/tests/baselines/reference/multipleExports.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/multipleExports.ts(10,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/multipleExports.ts(10,13): error TS2484: Export declaration conflicts with exported declaration of 'x'. +tests/cases/compiler/multipleExports.ts(9,5): error TS1194: Export declarations are not permitted in a namespace. +tests/cases/compiler/multipleExports.ts(9,13): error TS2484: Export declaration conflicts with exported declaration of 'x'. ==== tests/cases/compiler/multipleExports.ts (2 errors) ==== - export module M { export var v = 0; export let x; diff --git a/tests/baselines/reference/multipleExports.js b/tests/baselines/reference/multipleExports.js index 05276591447..284b24ef4f9 100644 --- a/tests/baselines/reference/multipleExports.js +++ b/tests/baselines/reference/multipleExports.js @@ -1,5 +1,4 @@ //// [multipleExports.ts] - export module M { export var v = 0; export let x; diff --git a/tests/baselines/reference/namespacesDeclaration1.js b/tests/baselines/reference/namespacesDeclaration1.js index b722dc1fc00..d9ecbf16369 100644 --- a/tests/baselines/reference/namespacesDeclaration1.js +++ b/tests/baselines/reference/namespacesDeclaration1.js @@ -1,5 +1,4 @@ //// [namespacesDeclaration1.ts] - module M { export namespace N { export module M2 { diff --git a/tests/baselines/reference/namespacesDeclaration1.symbols b/tests/baselines/reference/namespacesDeclaration1.symbols index 512bc9757aa..1589bf44696 100644 --- a/tests/baselines/reference/namespacesDeclaration1.symbols +++ b/tests/baselines/reference/namespacesDeclaration1.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/namespacesDeclaration1.ts === - module M { >M : Symbol(M, Decl(namespacesDeclaration1.ts, 0, 0)) export namespace N { ->N : Symbol(N, Decl(namespacesDeclaration1.ts, 1, 10)) +>N : Symbol(N, Decl(namespacesDeclaration1.ts, 0, 10)) export module M2 { ->M2 : Symbol(M2, Decl(namespacesDeclaration1.ts, 2, 23)) +>M2 : Symbol(M2, Decl(namespacesDeclaration1.ts, 1, 23)) export interface I {} ->I : Symbol(I, Decl(namespacesDeclaration1.ts, 3, 24)) +>I : Symbol(I, Decl(namespacesDeclaration1.ts, 2, 24)) } } } diff --git a/tests/baselines/reference/namespacesDeclaration1.types b/tests/baselines/reference/namespacesDeclaration1.types index e99f5d0e6c3..1b671f18706 100644 --- a/tests/baselines/reference/namespacesDeclaration1.types +++ b/tests/baselines/reference/namespacesDeclaration1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/namespacesDeclaration1.ts === - module M { >M : any diff --git a/tests/baselines/reference/namespacesDeclaration2.errors.txt b/tests/baselines/reference/namespacesDeclaration2.errors.txt index 50c64b7d83a..1f6ff170be7 100644 --- a/tests/baselines/reference/namespacesDeclaration2.errors.txt +++ b/tests/baselines/reference/namespacesDeclaration2.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/namespacesDeclaration2.ts(13,13): error TS2694: Namespace 'N' has no exported member 'S'. -tests/cases/compiler/namespacesDeclaration2.ts(14,12): error TS2694: Namespace 'M' has no exported member 'F'. -tests/cases/compiler/namespacesDeclaration2.ts(15,11): error TS2694: Namespace 'ns' has no exported member 'A'. +tests/cases/compiler/namespacesDeclaration2.ts(12,13): error TS2694: Namespace 'N' has no exported member 'S'. +tests/cases/compiler/namespacesDeclaration2.ts(13,12): error TS2694: Namespace 'M' has no exported member 'F'. +tests/cases/compiler/namespacesDeclaration2.ts(14,11): error TS2694: Namespace 'ns' has no exported member 'A'. ==== tests/cases/compiler/namespacesDeclaration2.ts (3 errors) ==== - namespace N { function S() {} } diff --git a/tests/baselines/reference/namespacesDeclaration2.js b/tests/baselines/reference/namespacesDeclaration2.js index d680e781145..7c74da322d8 100644 --- a/tests/baselines/reference/namespacesDeclaration2.js +++ b/tests/baselines/reference/namespacesDeclaration2.js @@ -1,5 +1,4 @@ //// [namespacesDeclaration2.ts] - namespace N { function S() {} } diff --git a/tests/baselines/reference/narrowedConstInMethod.js b/tests/baselines/reference/narrowedConstInMethod.js index f4cdc3def91..e2bd1c1cd21 100644 --- a/tests/baselines/reference/narrowedConstInMethod.js +++ b/tests/baselines/reference/narrowedConstInMethod.js @@ -1,5 +1,4 @@ //// [narrowedConstInMethod.ts] - function f() { const x: string | null = {}; if (x !== null) { diff --git a/tests/baselines/reference/narrowedConstInMethod.symbols b/tests/baselines/reference/narrowedConstInMethod.symbols index 1fd05dcea5e..f16837bf1bd 100644 --- a/tests/baselines/reference/narrowedConstInMethod.symbols +++ b/tests/baselines/reference/narrowedConstInMethod.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/narrowedConstInMethod.ts === - function f() { >f : Symbol(f, Decl(narrowedConstInMethod.ts, 0, 0)) const x: string | null = {}; ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) if (x !== null) { ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) return { bar() { return x.length; } // Error: possibly null x ->bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 4, 16)) +>bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 3, 16)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }; @@ -21,19 +20,19 @@ function f() { } function f2() { ->f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 8, 1)) +>f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 7, 1)) const x: string | null = {}; ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) if (x !== null) { ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) return class { bar() { return x.length; } // Error: possibly null x ->bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 13, 22)) +>bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 12, 22)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }; diff --git a/tests/baselines/reference/narrowedConstInMethod.types b/tests/baselines/reference/narrowedConstInMethod.types index a73f2edfccb..1f3886cc588 100644 --- a/tests/baselines/reference/narrowedConstInMethod.types +++ b/tests/baselines/reference/narrowedConstInMethod.types @@ -1,5 +1,4 @@ === tests/cases/compiler/narrowedConstInMethod.ts === - function f() { >f : () => { bar(): number; } | undefined diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.js b/tests/baselines/reference/narrowingByDiscriminantInLoop.js index 88cc87772dd..a5eea76cfd5 100644 --- a/tests/baselines/reference/narrowingByDiscriminantInLoop.js +++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.js @@ -1,5 +1,4 @@ //// [narrowingByDiscriminantInLoop.ts] - // Repro from #9977 type IDLMemberTypes = OperationMemberType | ConstantMemberType; diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols b/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols index edb0f1958c2..572a775293d 100644 --- a/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols +++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols @@ -1,238 +1,237 @@ === tests/cases/compiler/narrowingByDiscriminantInLoop.ts === - // Repro from #9977 type IDLMemberTypes = OperationMemberType | ConstantMemberType; >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0)) ->OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 11, 1)) ->ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 16, 1)) +>OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 10, 1)) +>ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 15, 1)) interface IDLTypeDescription { ->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63)) +>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63)) origin: string; ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) } interface InterfaceType { ->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1)) +>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1)) members: IDLMemberTypes[]; ->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) +>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0)) } interface OperationMemberType { ->OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 11, 1)) +>OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 10, 1)) type: "operation"; ->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) +>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) idlType: IDLTypeDescription; ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63)) } interface ConstantMemberType { ->ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 16, 1)) +>ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 15, 1)) type: "const"; ->type : Symbol(ConstantMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>type : Symbol(ConstantMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) idlType: string; ->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) +>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) } function insertInterface(callbackType: InterfaceType) { ->insertInterface : Symbol(insertInterface, Decl(narrowingByDiscriminantInLoop.ts, 21, 1)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 23, 25)) ->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1)) +>insertInterface : Symbol(insertInterface, Decl(narrowingByDiscriminantInLoop.ts, 20, 1)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 22, 25)) +>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1)) for (const memberType of callbackType.members) { ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 23, 25)) ->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 22, 25)) +>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) if (memberType.type === "const") { ->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) memberType.idlType; // string ->memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) +>memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) } else if (memberType.type === "operation") { ->memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) +>memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) memberType.idlType.origin; // string ->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) (memberType.idlType as IDLTypeDescription); ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63)) } } } function insertInterface2(callbackType: InterfaceType) { ->insertInterface2 : Symbol(insertInterface2, Decl(narrowingByDiscriminantInLoop.ts, 33, 1)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 35, 26)) ->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1)) +>insertInterface2 : Symbol(insertInterface2, Decl(narrowingByDiscriminantInLoop.ts, 32, 1)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 34, 26)) +>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1)) for (const memberType of callbackType.members) { ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14)) ->callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 35, 26)) ->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14)) +>callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 34, 26)) +>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) if (memberType.type === "operation") { ->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14)) ->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14)) +>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) memberType.idlType.origin; // string ->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) } } } function foo(memberType: IDLMemberTypes) { ->foo : Symbol(foo, Decl(narrowingByDiscriminantInLoop.ts, 41, 1)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) +>foo : Symbol(foo, Decl(narrowingByDiscriminantInLoop.ts, 40, 1)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0)) if (memberType.type === "const") { ->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) memberType.idlType; // string ->memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) +>memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) } else if (memberType.type === "operation") { ->memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) +>memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) memberType.idlType.origin; // string ->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) } } // Repro for issue similar to #8383 interface A { ->A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1)) +>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 49, 1)) kind: true; ->kind : Symbol(A.kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13)) +>kind : Symbol(A.kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13)) prop: { a: string; }; ->prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) +>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) } interface B { ->B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1)) +>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 56, 1)) kind: false; ->kind : Symbol(B.kind, Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>kind : Symbol(B.kind, Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) prop: { b: string; } ->prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) +>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) } function f1(x: A | B) { ->f1 : Symbol(f1, Decl(narrowingByDiscriminantInLoop.ts, 62, 1)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1)) ->B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1)) +>f1 : Symbol(f1, Decl(narrowingByDiscriminantInLoop.ts, 61, 1)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 49, 1)) +>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 56, 1)) while (true) { x.prop; ->x.prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15), Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15), Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) +>x.prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15), Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15), Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) if (x.kind === true) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.a; ->x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) ->x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) +>x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) +>x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) } if (x.kind === false) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.b; ->x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) ->x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) +>x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) +>x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) } } } function f2(x: A | B) { ->f2 : Symbol(f2, Decl(narrowingByDiscriminantInLoop.ts, 74, 1)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1)) ->B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1)) +>f2 : Symbol(f2, Decl(narrowingByDiscriminantInLoop.ts, 73, 1)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 49, 1)) +>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 56, 1)) while (true) { if (x.kind) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.a; ->x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) ->x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) +>x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) +>x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) } if (!x.kind) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.b; ->x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) ->x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) +>x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) +>x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) } } } diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.types b/tests/baselines/reference/narrowingByDiscriminantInLoop.types index c0f6fe73bca..7c4ab046f4e 100644 --- a/tests/baselines/reference/narrowingByDiscriminantInLoop.types +++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.types @@ -1,5 +1,4 @@ === tests/cases/compiler/narrowingByDiscriminantInLoop.ts === - // Repro from #9977 type IDLMemberTypes = OperationMemberType | ConstantMemberType; diff --git a/tests/baselines/reference/narrowingConstrainedTypeParameter.js b/tests/baselines/reference/narrowingConstrainedTypeParameter.js index 4663e706d1b..fa9a18126d6 100644 --- a/tests/baselines/reference/narrowingConstrainedTypeParameter.js +++ b/tests/baselines/reference/narrowingConstrainedTypeParameter.js @@ -1,5 +1,4 @@ //// [narrowingConstrainedTypeParameter.ts] - // Repro from #10811 interface Pet { diff --git a/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols b/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols index 89ca39e98a2..0510f1b5945 100644 --- a/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols +++ b/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/narrowingConstrainedTypeParameter.ts === - // Repro from #10811 interface Pet { >Pet : Symbol(Pet, Decl(narrowingConstrainedTypeParameter.ts, 0, 0)) name: string; ->name : Symbol(Pet.name, Decl(narrowingConstrainedTypeParameter.ts, 3, 15)) +>name : Symbol(Pet.name, Decl(narrowingConstrainedTypeParameter.ts, 2, 15)) } function isPet(pet: any): pet is Pet { ->isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 5, 1)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 7, 15)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 7, 15)) +>isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 4, 1)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 6, 15)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 6, 15)) >Pet : Symbol(Pet, Decl(narrowingConstrainedTypeParameter.ts, 0, 0)) return typeof pet.name === "string"; ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 7, 15)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 6, 15)) } export function speak(pet: TPet, voice: (pet: TPet) => string): string { ->speak : Symbol(speak, Decl(narrowingConstrainedTypeParameter.ts, 9, 1)) ->TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 11, 22)) +>speak : Symbol(speak, Decl(narrowingConstrainedTypeParameter.ts, 8, 1)) +>TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 10, 22)) >Pet : Symbol(Pet, Decl(narrowingConstrainedTypeParameter.ts, 0, 0)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 40)) ->TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 11, 22)) ->voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 11, 50)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 59)) ->TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 11, 22)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 40)) +>TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 10, 22)) +>voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 10, 50)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 59)) +>TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 10, 22)) if (!isPet(pet)) { ->isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 5, 1)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 40)) +>isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 4, 1)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 40)) throw new Error("Expected \"pet\" to be a Pet"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } return voice(pet); ->voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 11, 50)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 40)) +>voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 10, 50)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 40)) } diff --git a/tests/baselines/reference/narrowingConstrainedTypeParameter.types b/tests/baselines/reference/narrowingConstrainedTypeParameter.types index 348716ab3c4..1c02ceeb825 100644 --- a/tests/baselines/reference/narrowingConstrainedTypeParameter.types +++ b/tests/baselines/reference/narrowingConstrainedTypeParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/narrowingConstrainedTypeParameter.ts === - // Repro from #10811 interface Pet { diff --git a/tests/baselines/reference/neverType.js b/tests/baselines/reference/neverType.js index a1e4c71f803..e21a2fedf8e 100644 --- a/tests/baselines/reference/neverType.js +++ b/tests/baselines/reference/neverType.js @@ -1,6 +1,4 @@ //// [neverType.ts] - - function error(message: string): never { throw new Error(message); } diff --git a/tests/baselines/reference/neverType.symbols b/tests/baselines/reference/neverType.symbols index 4156934ddcc..f4e8329e7ea 100644 --- a/tests/baselines/reference/neverType.symbols +++ b/tests/baselines/reference/neverType.symbols @@ -1,65 +1,63 @@ === tests/cases/conformance/types/never/neverType.ts === - - function error(message: string): never { >error : Symbol(error, Decl(neverType.ts, 0, 0)) ->message : Symbol(message, Decl(neverType.ts, 2, 15)) +>message : Symbol(message, Decl(neverType.ts, 0, 15)) throw new Error(message); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->message : Symbol(message, Decl(neverType.ts, 2, 15)) +>message : Symbol(message, Decl(neverType.ts, 0, 15)) } function errorVoid(message: string) { ->errorVoid : Symbol(errorVoid, Decl(neverType.ts, 4, 1)) ->message : Symbol(message, Decl(neverType.ts, 6, 19)) +>errorVoid : Symbol(errorVoid, Decl(neverType.ts, 2, 1)) +>message : Symbol(message, Decl(neverType.ts, 4, 19)) throw new Error(message); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->message : Symbol(message, Decl(neverType.ts, 6, 19)) +>message : Symbol(message, Decl(neverType.ts, 4, 19)) } function fail() { ->fail : Symbol(fail, Decl(neverType.ts, 8, 1)) +>fail : Symbol(fail, Decl(neverType.ts, 6, 1)) return error("Something failed"); >error : Symbol(error, Decl(neverType.ts, 0, 0)) } function failOrThrow(shouldFail: boolean) { ->failOrThrow : Symbol(failOrThrow, Decl(neverType.ts, 12, 1)) ->shouldFail : Symbol(shouldFail, Decl(neverType.ts, 14, 21)) +>failOrThrow : Symbol(failOrThrow, Decl(neverType.ts, 10, 1)) +>shouldFail : Symbol(shouldFail, Decl(neverType.ts, 12, 21)) if (shouldFail) { ->shouldFail : Symbol(shouldFail, Decl(neverType.ts, 14, 21)) +>shouldFail : Symbol(shouldFail, Decl(neverType.ts, 12, 21)) return fail(); ->fail : Symbol(fail, Decl(neverType.ts, 8, 1)) +>fail : Symbol(fail, Decl(neverType.ts, 6, 1)) } throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function infiniteLoop1() { ->infiniteLoop1 : Symbol(infiniteLoop1, Decl(neverType.ts, 19, 1)) +>infiniteLoop1 : Symbol(infiniteLoop1, Decl(neverType.ts, 17, 1)) while (true) { } } function infiniteLoop2(): never { ->infiniteLoop2 : Symbol(infiniteLoop2, Decl(neverType.ts, 24, 1)) +>infiniteLoop2 : Symbol(infiniteLoop2, Decl(neverType.ts, 22, 1)) while (true) { } } function move1(direction: "up" | "down") { ->move1 : Symbol(move1, Decl(neverType.ts, 29, 1)) ->direction : Symbol(direction, Decl(neverType.ts, 31, 15)) +>move1 : Symbol(move1, Decl(neverType.ts, 27, 1)) +>direction : Symbol(direction, Decl(neverType.ts, 29, 15)) switch (direction) { ->direction : Symbol(direction, Decl(neverType.ts, 31, 15)) +>direction : Symbol(direction, Decl(neverType.ts, 29, 15)) case "up": return 1; @@ -71,111 +69,111 @@ function move1(direction: "up" | "down") { } function move2(direction: "up" | "down") { ->move2 : Symbol(move2, Decl(neverType.ts, 39, 1)) ->direction : Symbol(direction, Decl(neverType.ts, 41, 15)) +>move2 : Symbol(move2, Decl(neverType.ts, 37, 1)) +>direction : Symbol(direction, Decl(neverType.ts, 39, 15)) return direction === "up" ? 1 : ->direction : Symbol(direction, Decl(neverType.ts, 41, 15)) +>direction : Symbol(direction, Decl(neverType.ts, 39, 15)) direction === "down" ? -1 : ->direction : Symbol(direction, Decl(neverType.ts, 41, 15)) +>direction : Symbol(direction, Decl(neverType.ts, 39, 15)) error("Should never get here"); >error : Symbol(error, Decl(neverType.ts, 0, 0)) } function check(x: T | undefined) { ->check : Symbol(check, Decl(neverType.ts, 45, 1)) ->T : Symbol(T, Decl(neverType.ts, 47, 15)) ->x : Symbol(x, Decl(neverType.ts, 47, 18)) ->T : Symbol(T, Decl(neverType.ts, 47, 15)) +>check : Symbol(check, Decl(neverType.ts, 43, 1)) +>T : Symbol(T, Decl(neverType.ts, 45, 15)) +>x : Symbol(x, Decl(neverType.ts, 45, 18)) +>T : Symbol(T, Decl(neverType.ts, 45, 15)) return x || error("Undefined value"); ->x : Symbol(x, Decl(neverType.ts, 47, 18)) +>x : Symbol(x, Decl(neverType.ts, 45, 18)) >error : Symbol(error, Decl(neverType.ts, 0, 0)) } class C { ->C : Symbol(C, Decl(neverType.ts, 49, 1)) +>C : Symbol(C, Decl(neverType.ts, 47, 1)) void1() { ->void1 : Symbol(C.void1, Decl(neverType.ts, 51, 9)) +>void1 : Symbol(C.void1, Decl(neverType.ts, 49, 9)) throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } void2() { ->void2 : Symbol(C.void2, Decl(neverType.ts, 54, 5)) +>void2 : Symbol(C.void2, Decl(neverType.ts, 52, 5)) while (true) {} } never1(): never { ->never1 : Symbol(C.never1, Decl(neverType.ts, 57, 5)) +>never1 : Symbol(C.never1, Decl(neverType.ts, 55, 5)) throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } never2(): never { ->never2 : Symbol(C.never2, Decl(neverType.ts, 60, 5)) +>never2 : Symbol(C.never2, Decl(neverType.ts, 58, 5)) while (true) {} } } function f1(x: string | number) { ->f1 : Symbol(f1, Decl(neverType.ts, 64, 1)) ->x : Symbol(x, Decl(neverType.ts, 66, 12)) +>f1 : Symbol(f1, Decl(neverType.ts, 62, 1)) +>x : Symbol(x, Decl(neverType.ts, 64, 12)) if (typeof x === "boolean") { ->x : Symbol(x, Decl(neverType.ts, 66, 12)) +>x : Symbol(x, Decl(neverType.ts, 64, 12)) x; // never ->x : Symbol(x, Decl(neverType.ts, 66, 12)) +>x : Symbol(x, Decl(neverType.ts, 64, 12)) } } function f2(x: string | number) { ->f2 : Symbol(f2, Decl(neverType.ts, 70, 1)) ->x : Symbol(x, Decl(neverType.ts, 72, 12)) +>f2 : Symbol(f2, Decl(neverType.ts, 68, 1)) +>x : Symbol(x, Decl(neverType.ts, 70, 12)) while (true) { if (typeof x === "boolean") { ->x : Symbol(x, Decl(neverType.ts, 72, 12)) +>x : Symbol(x, Decl(neverType.ts, 70, 12)) return x; // never ->x : Symbol(x, Decl(neverType.ts, 72, 12)) +>x : Symbol(x, Decl(neverType.ts, 70, 12)) } } } function test(cb: () => string) { ->test : Symbol(test, Decl(neverType.ts, 78, 1)) ->cb : Symbol(cb, Decl(neverType.ts, 80, 14)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) +>cb : Symbol(cb, Decl(neverType.ts, 78, 14)) let s = cb(); ->s : Symbol(s, Decl(neverType.ts, 81, 7)) ->cb : Symbol(cb, Decl(neverType.ts, 80, 14)) +>s : Symbol(s, Decl(neverType.ts, 79, 7)) +>cb : Symbol(cb, Decl(neverType.ts, 78, 14)) return s; ->s : Symbol(s, Decl(neverType.ts, 81, 7)) +>s : Symbol(s, Decl(neverType.ts, 79, 7)) } let errorCallback = () => error("Error callback"); ->errorCallback : Symbol(errorCallback, Decl(neverType.ts, 85, 3)) +>errorCallback : Symbol(errorCallback, Decl(neverType.ts, 83, 3)) >error : Symbol(error, Decl(neverType.ts, 0, 0)) test(() => "hello"); ->test : Symbol(test, Decl(neverType.ts, 78, 1)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) test(() => fail()); ->test : Symbol(test, Decl(neverType.ts, 78, 1)) ->fail : Symbol(fail, Decl(neverType.ts, 8, 1)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) +>fail : Symbol(fail, Decl(neverType.ts, 6, 1)) test(() => { throw new Error(); }) ->test : Symbol(test, Decl(neverType.ts, 78, 1)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) test(errorCallback); ->test : Symbol(test, Decl(neverType.ts, 78, 1)) ->errorCallback : Symbol(errorCallback, Decl(neverType.ts, 85, 3)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) +>errorCallback : Symbol(errorCallback, Decl(neverType.ts, 83, 3)) diff --git a/tests/baselines/reference/neverType.types b/tests/baselines/reference/neverType.types index 9555285e4be..efedf4629ac 100644 --- a/tests/baselines/reference/neverType.types +++ b/tests/baselines/reference/neverType.types @@ -1,6 +1,4 @@ === tests/cases/conformance/types/never/neverType.ts === - - function error(message: string): never { >error : (message: string) => never >message : string diff --git a/tests/baselines/reference/neverTypeErrors2.errors.txt b/tests/baselines/reference/neverTypeErrors2.errors.txt index 60e6947f44a..5f9bb26344f 100644 --- a/tests/baselines/reference/neverTypeErrors2.errors.txt +++ b/tests/baselines/reference/neverTypeErrors2.errors.txt @@ -1,16 +1,15 @@ -tests/cases/conformance/types/never/neverTypeErrors2.ts(4,5): error TS2322: Type '1' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(5,5): error TS2322: Type '"abc"' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(6,5): error TS2322: Type 'false' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(7,5): error TS2322: Type 'undefined' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(8,5): error TS2322: Type 'null' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(9,5): error TS2322: Type '{}' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(13,5): error TS2322: Type 'undefined' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(17,5): error TS2322: Type '1' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(20,16): error TS2534: A function returning 'never' cannot have a reachable end point. +tests/cases/conformance/types/never/neverTypeErrors2.ts(3,5): error TS2322: Type '1' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(4,5): error TS2322: Type '"abc"' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(5,5): error TS2322: Type 'false' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(6,5): error TS2322: Type 'undefined' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(7,5): error TS2322: Type 'null' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(8,5): error TS2322: Type '{}' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(12,5): error TS2322: Type 'undefined' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(16,5): error TS2322: Type '1' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(19,16): error TS2534: A function returning 'never' cannot have a reachable end point. ==== tests/cases/conformance/types/never/neverTypeErrors2.ts (9 errors) ==== - function f1() { let x: never; x = 1; diff --git a/tests/baselines/reference/neverTypeErrors2.js b/tests/baselines/reference/neverTypeErrors2.js index 18c92922bc1..70bdb4673ca 100644 --- a/tests/baselines/reference/neverTypeErrors2.js +++ b/tests/baselines/reference/neverTypeErrors2.js @@ -1,5 +1,4 @@ //// [neverTypeErrors2.ts] - function f1() { let x: never; x = 1; diff --git a/tests/baselines/reference/newExpressionWithCast.errors.txt b/tests/baselines/reference/newExpressionWithCast.errors.txt index c8f44b96ae2..4fc4ee24d8c 100644 --- a/tests/baselines/reference/newExpressionWithCast.errors.txt +++ b/tests/baselines/reference/newExpressionWithCast.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/newExpressionWithCast.ts(4,12): error TS7009: 'new' expression, whose target lacks a construct signature, implicitly has an 'any' type. -tests/cases/compiler/newExpressionWithCast.ts(8,13): error TS2365: Operator '>' cannot be applied to types 'boolean' and 'void'. -tests/cases/compiler/newExpressionWithCast.ts(8,17): error TS1109: Expression expected. -tests/cases/compiler/newExpressionWithCast.ts(8,18): error TS2304: Cannot find name 'any'. +tests/cases/compiler/newExpressionWithCast.ts(3,12): error TS7009: 'new' expression, whose target lacks a construct signature, implicitly has an 'any' type. +tests/cases/compiler/newExpressionWithCast.ts(7,13): error TS2365: Operator '>' cannot be applied to types 'boolean' and 'void'. +tests/cases/compiler/newExpressionWithCast.ts(7,17): error TS1109: Expression expected. +tests/cases/compiler/newExpressionWithCast.ts(7,18): error TS2304: Cannot find name 'any'. ==== tests/cases/compiler/newExpressionWithCast.ts (4 errors) ==== - function Test() { } // valid but error with noImplicitAny var test = new Test(); diff --git a/tests/baselines/reference/newExpressionWithCast.js b/tests/baselines/reference/newExpressionWithCast.js index 8743d9b83bc..9be7105f688 100644 --- a/tests/baselines/reference/newExpressionWithCast.js +++ b/tests/baselines/reference/newExpressionWithCast.js @@ -1,5 +1,4 @@ //// [newExpressionWithCast.ts] - function Test() { } // valid but error with noImplicitAny var test = new Test(); diff --git a/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt b/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt index f469885e405..aff01f3347e 100644 --- a/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt +++ b/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/f1.d.ts(13,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. +tests/cases/compiler/f1.d.ts(12,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. ==== tests/cases/compiler/f1.d.ts (1 errors) ==== - export {}; declare module M.M1 { @@ -20,7 +19,6 @@ tests/cases/compiler/f1.d.ts(13,5): error TS2667: Imports are not permitted in m } ==== tests/cases/compiler/main.ts (0 errors) ==== - Symbol.observable; new Cls().x let c = a + b + X; \ No newline at end of file diff --git a/tests/baselines/reference/newNamesInGlobalAugmentations1.js b/tests/baselines/reference/newNamesInGlobalAugmentations1.js index 0400f4c3751..283f03c02ee 100644 --- a/tests/baselines/reference/newNamesInGlobalAugmentations1.js +++ b/tests/baselines/reference/newNamesInGlobalAugmentations1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/newNamesInGlobalAugmentations1.ts] //// //// [f1.d.ts] - export {}; declare module M.M1 { @@ -17,7 +16,6 @@ declare global { } //// [main.ts] - Symbol.observable; new Cls().x let c = a + b + X; diff --git a/tests/baselines/reference/newOperatorConformance.js b/tests/baselines/reference/newOperatorConformance.js index 3b84cbd6698..46a1f3c7cac 100644 --- a/tests/baselines/reference/newOperatorConformance.js +++ b/tests/baselines/reference/newOperatorConformance.js @@ -1,5 +1,4 @@ //// [newOperatorConformance.ts] - class C0 { } diff --git a/tests/baselines/reference/newOperatorConformance.symbols b/tests/baselines/reference/newOperatorConformance.symbols index 8467e1741fc..aa3fe289166 100644 --- a/tests/baselines/reference/newOperatorConformance.symbols +++ b/tests/baselines/reference/newOperatorConformance.symbols @@ -1,135 +1,134 @@ === tests/cases/conformance/expressions/newOperator/newOperatorConformance.ts === - class C0 { >C0 : Symbol(C0, Decl(newOperatorConformance.ts, 0, 0)) } class C1 { ->C1 : Symbol(C1, Decl(newOperatorConformance.ts, 3, 1)) +>C1 : Symbol(C1, Decl(newOperatorConformance.ts, 2, 1)) constructor(n: number, s: string) { } ->n : Symbol(n, Decl(newOperatorConformance.ts, 5, 16)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 5, 26)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 4, 16)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 4, 26)) } class T { ->T : Symbol(T, Decl(newOperatorConformance.ts, 6, 1)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 8, 8)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 5, 1)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 7, 8)) constructor(n?: T) { } ->n : Symbol(n, Decl(newOperatorConformance.ts, 9, 16)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 8, 8)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 8, 16)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 7, 8)) } var anyCtor: { ->anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 12, 3)) +>anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 11, 3)) new (): any; }; var anyCtor1: { ->anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 16, 3)) +>anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 15, 3)) new (n): any; ->n : Symbol(n, Decl(newOperatorConformance.ts, 17, 9)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 16, 9)) }; interface nestedCtor { ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) new (): nestedCtor; ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) } var nestedCtor: nestedCtor; ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) // Construct expression with no parentheses for construct signature with 0 parameters var a = new C0; ->a : Symbol(a, Decl(newOperatorConformance.ts, 26, 3), Decl(newOperatorConformance.ts, 27, 3)) +>a : Symbol(a, Decl(newOperatorConformance.ts, 25, 3), Decl(newOperatorConformance.ts, 26, 3)) >C0 : Symbol(C0, Decl(newOperatorConformance.ts, 0, 0)) var a: C0; ->a : Symbol(a, Decl(newOperatorConformance.ts, 26, 3), Decl(newOperatorConformance.ts, 27, 3)) +>a : Symbol(a, Decl(newOperatorConformance.ts, 25, 3), Decl(newOperatorConformance.ts, 26, 3)) >C0 : Symbol(C0, Decl(newOperatorConformance.ts, 0, 0)) // Generic construct expression with no parentheses var c1 = new T; ->c1 : Symbol(c1, Decl(newOperatorConformance.ts, 31, 3), Decl(newOperatorConformance.ts, 32, 3)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 6, 1)) +>c1 : Symbol(c1, Decl(newOperatorConformance.ts, 30, 3), Decl(newOperatorConformance.ts, 31, 3)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 5, 1)) var c1: T<{}>; ->c1 : Symbol(c1, Decl(newOperatorConformance.ts, 31, 3), Decl(newOperatorConformance.ts, 32, 3)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 6, 1)) +>c1 : Symbol(c1, Decl(newOperatorConformance.ts, 30, 3), Decl(newOperatorConformance.ts, 31, 3)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 5, 1)) // Construct expression where constructor is of type 'any' with no parentheses var d = new anyCtor; ->d : Symbol(d, Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 36, 3), Decl(newOperatorConformance.ts, 39, 3)) ->anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 12, 3)) +>d : Symbol(d, Decl(newOperatorConformance.ts, 34, 3), Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 38, 3)) +>anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 11, 3)) var d: any; ->d : Symbol(d, Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 36, 3), Decl(newOperatorConformance.ts, 39, 3)) +>d : Symbol(d, Decl(newOperatorConformance.ts, 34, 3), Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 38, 3)) // Construct expression where constructor is of type 'any' with > 1 arg var d = new anyCtor1(undefined); ->d : Symbol(d, Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 36, 3), Decl(newOperatorConformance.ts, 39, 3)) ->anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 16, 3)) +>d : Symbol(d, Decl(newOperatorConformance.ts, 34, 3), Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 38, 3)) +>anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 15, 3)) >undefined : Symbol(undefined) // Construct expression of type where apparent type has a construct signature with 0 arguments function newFn1(s: T) { ->newFn1 : Symbol(newFn1, Decl(newOperatorConformance.ts, 39, 32)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 42, 16)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 42, 46)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 42, 16)) +>newFn1 : Symbol(newFn1, Decl(newOperatorConformance.ts, 38, 32)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 41, 16)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 41, 46)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 41, 16)) var p = new s; ->p : Symbol(p, Decl(newOperatorConformance.ts, 43, 7), Decl(newOperatorConformance.ts, 44, 7)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 42, 46)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 42, 7), Decl(newOperatorConformance.ts, 43, 7)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 41, 46)) var p: number; ->p : Symbol(p, Decl(newOperatorConformance.ts, 43, 7), Decl(newOperatorConformance.ts, 44, 7)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 42, 7), Decl(newOperatorConformance.ts, 43, 7)) } // Construct expression of type where apparent type has a construct signature with 1 arguments function newFn2(s: T) { ->newFn2 : Symbol(newFn2, Decl(newOperatorConformance.ts, 45, 1)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 48, 16)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 48, 33)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 48, 54)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 48, 16)) +>newFn2 : Symbol(newFn2, Decl(newOperatorConformance.ts, 44, 1)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 47, 16)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 47, 33)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 47, 54)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 47, 16)) var p = new s(32); ->p : Symbol(p, Decl(newOperatorConformance.ts, 49, 7), Decl(newOperatorConformance.ts, 50, 7)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 48, 54)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 48, 7), Decl(newOperatorConformance.ts, 49, 7)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 47, 54)) var p: string; ->p : Symbol(p, Decl(newOperatorConformance.ts, 49, 7), Decl(newOperatorConformance.ts, 50, 7)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 48, 7), Decl(newOperatorConformance.ts, 49, 7)) } // Construct expression of void returning function function fnVoid(): void { } ->fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 51, 1)) +>fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 50, 1)) var t = new fnVoid(); ->t : Symbol(t, Decl(newOperatorConformance.ts, 55, 3), Decl(newOperatorConformance.ts, 56, 3)) ->fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 51, 1)) +>t : Symbol(t, Decl(newOperatorConformance.ts, 54, 3), Decl(newOperatorConformance.ts, 55, 3)) +>fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 50, 1)) var t: any; ->t : Symbol(t, Decl(newOperatorConformance.ts, 55, 3), Decl(newOperatorConformance.ts, 56, 3)) +>t : Symbol(t, Decl(newOperatorConformance.ts, 54, 3), Decl(newOperatorConformance.ts, 55, 3)) // Chained new expressions var nested = new (new (new nestedCtor())())(); ->nested : Symbol(nested, Decl(newOperatorConformance.ts, 59, 3)) ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nested : Symbol(nested, Decl(newOperatorConformance.ts, 58, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) var n = new nested(); ->n : Symbol(n, Decl(newOperatorConformance.ts, 60, 3), Decl(newOperatorConformance.ts, 61, 3)) ->nested : Symbol(nested, Decl(newOperatorConformance.ts, 59, 3)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 59, 3), Decl(newOperatorConformance.ts, 60, 3)) +>nested : Symbol(nested, Decl(newOperatorConformance.ts, 58, 3)) var n = new nested(); ->n : Symbol(n, Decl(newOperatorConformance.ts, 60, 3), Decl(newOperatorConformance.ts, 61, 3)) ->nested : Symbol(nested, Decl(newOperatorConformance.ts, 59, 3)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 59, 3), Decl(newOperatorConformance.ts, 60, 3)) +>nested : Symbol(nested, Decl(newOperatorConformance.ts, 58, 3)) diff --git a/tests/baselines/reference/newOperatorConformance.types b/tests/baselines/reference/newOperatorConformance.types index c7fb0125a1a..6a780871677 100644 --- a/tests/baselines/reference/newOperatorConformance.types +++ b/tests/baselines/reference/newOperatorConformance.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/newOperator/newOperatorConformance.ts === - class C0 { >C0 : C0 diff --git a/tests/baselines/reference/newOperatorErrorCases.errors.txt b/tests/baselines/reference/newOperatorErrorCases.errors.txt index b2947a1d218..c41efaac289 100644 --- a/tests/baselines/reference/newOperatorErrorCases.errors.txt +++ b/tests/baselines/reference/newOperatorErrorCases.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(27,16): error TS1005: ',' expected. -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(27,16): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(32,23): error TS1005: '(' expected. -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(37,9): error TS2350: Only a void function can be called with the 'new' keyword. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(26,16): error TS1005: ',' expected. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(26,16): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(31,23): error TS1005: '(' expected. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(36,9): error TS2350: Only a void function can be called with the 'new' keyword. ==== tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts (4 errors) ==== - class C0 { } diff --git a/tests/baselines/reference/newOperatorErrorCases.js b/tests/baselines/reference/newOperatorErrorCases.js index 6d57f9a090e..5f179fece77 100644 --- a/tests/baselines/reference/newOperatorErrorCases.js +++ b/tests/baselines/reference/newOperatorErrorCases.js @@ -1,5 +1,4 @@ //// [newOperatorErrorCases.ts] - class C0 { } diff --git a/tests/baselines/reference/newWithSpread.errors.txt b/tests/baselines/reference/newWithSpread.errors.txt index 293c7054e4c..e91a6757ead 100644 --- a/tests/baselines/reference/newWithSpread.errors.txt +++ b/tests/baselines/reference/newWithSpread.errors.txt @@ -1,33 +1,32 @@ +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(36,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(37,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(38,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(41,8): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(42,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(40,8): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(41,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(45,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(46,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(47,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(50,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(51,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(52,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(55,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(56,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(57,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(60,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(61,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(62,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(65,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(66,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(67,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(70,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(71,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(72,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(75,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(76,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(77,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(80,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(81,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(82,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(85,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(86,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(87,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(90,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(91,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(92,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(95,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(96,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(97,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. ==== tests/cases/conformance/expressions/functionCalls/newWithSpread.ts (26 errors) ==== - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpread.js b/tests/baselines/reference/newWithSpread.js index c6ea3b44c15..f08902b14be 100644 --- a/tests/baselines/reference/newWithSpread.js +++ b/tests/baselines/reference/newWithSpread.js @@ -1,5 +1,4 @@ //// [newWithSpread.ts] - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpreadES5.js b/tests/baselines/reference/newWithSpreadES5.js index 125ac9f0412..a74a5a729a6 100644 --- a/tests/baselines/reference/newWithSpreadES5.js +++ b/tests/baselines/reference/newWithSpreadES5.js @@ -1,5 +1,4 @@ //// [newWithSpreadES5.ts] - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpreadES5.symbols b/tests/baselines/reference/newWithSpreadES5.symbols index 7db4e6f1063..dc0b56a8c27 100644 --- a/tests/baselines/reference/newWithSpreadES5.symbols +++ b/tests/baselines/reference/newWithSpreadES5.symbols @@ -1,84 +1,83 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts === - function f(x: number, y: number, ...z: string[]) { >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->x : Symbol(x, Decl(newWithSpreadES5.ts, 1, 11)) ->y : Symbol(y, Decl(newWithSpreadES5.ts, 1, 21)) ->z : Symbol(z, Decl(newWithSpreadES5.ts, 1, 32)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 0, 11)) +>y : Symbol(y, Decl(newWithSpreadES5.ts, 0, 21)) +>z : Symbol(z, Decl(newWithSpreadES5.ts, 0, 32)) } function f2(...x: string[]) {} ->f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 2, 1)) ->x : Symbol(x, Decl(newWithSpreadES5.ts, 4, 12)) +>f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 1, 1)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 3, 12)) interface A { ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) f: { ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new (x: number, y: number, ...z: string[]); ->x : Symbol(x, Decl(newWithSpreadES5.ts, 8, 13)) ->y : Symbol(y, Decl(newWithSpreadES5.ts, 8, 23)) ->z : Symbol(z, Decl(newWithSpreadES5.ts, 8, 34)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 7, 13)) +>y : Symbol(y, Decl(newWithSpreadES5.ts, 7, 23)) +>z : Symbol(z, Decl(newWithSpreadES5.ts, 7, 34)) } } class B { ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) constructor(x: number, y: number, ...z: string[]) {} ->x : Symbol(x, Decl(newWithSpreadES5.ts, 13, 16)) ->y : Symbol(y, Decl(newWithSpreadES5.ts, 13, 26)) ->z : Symbol(z, Decl(newWithSpreadES5.ts, 13, 37)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 12, 16)) +>y : Symbol(y, Decl(newWithSpreadES5.ts, 12, 26)) +>z : Symbol(z, Decl(newWithSpreadES5.ts, 12, 37)) } interface C { ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) "a-b": typeof B; ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) } interface D { ->D : Symbol(D, Decl(newWithSpreadES5.ts, 18, 1)) +>D : Symbol(D, Decl(newWithSpreadES5.ts, 17, 1)) 1: typeof B; ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) } var a: string[]; ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) var b: A; ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) var c: C; ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) var d: A[]; ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) var e: { [key: string]: A }; ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->key : Symbol(key, Decl(newWithSpreadES5.ts, 28, 10)) ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>key : Symbol(key, Decl(newWithSpreadES5.ts, 27, 10)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) var g: C[]; ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) var h: { [key: string]: C }; ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->key : Symbol(key, Decl(newWithSpreadES5.ts, 30, 10)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>key : Symbol(key, Decl(newWithSpreadES5.ts, 29, 10)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) var i: C[][]; ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) // Basic expression new f(1, 2, "string"); @@ -86,22 +85,22 @@ new f(1, 2, "string"); new f(1, 2, ...a); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new f(1, 2, ...a, "string"); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Multiple spreads arguments new f2(...a, ...a); ->f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 2, 1)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 1, 1)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new f(1 ,2, ...a, ...a); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Call expression new f(1, 2, "string")(); @@ -109,165 +108,165 @@ new f(1, 2, "string")(); new f(1, 2, ...a)(); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new f(1, 2, ...a, "string")(); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Property access expression new b.f(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new b.f(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new b.f(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Parenthesised expression new (b.f)(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new (b.f)(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new (b.f)(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression new d[1].f(1, 2, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new d[1].f(1, 2, ...a); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new d[1].f(1, 2, ...a, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression with a punctuated key new e["a-b"].f(1, 2, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new e["a-b"].f(1, 2, ...a); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new e["a-b"].f(1, 2, ...a, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Basic expression new B(1, 2, "string"); ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) new B(1, 2, ...a); ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new B(1, 2, ...a, "string"); ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Property access expression new c["a-b"](1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new c["a-b"](1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new c["a-b"](1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Parenthesised expression new (c["a-b"])(1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new (c["a-b"])(1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new (c["a-b"])(1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression new g[1]["a-b"](1, 2, "string"); ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new g[1]["a-b"](1, 2, ...a); ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new g[1]["a-b"](1, 2, ...a, "string"); ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression with a punctuated key new h["a-b"]["a-b"](1, 2, "string"); ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new h["a-b"]["a-b"](1, 2, ...a); ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new h["a-b"]["a-b"](1, 2, ...a, "string"); ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression with a number new i["a-b"][1](1, 2, "string"); ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) new i["a-b"][1](1, 2, ...a); ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new i["a-b"][1](1, 2, ...a, "string"); ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) diff --git a/tests/baselines/reference/newWithSpreadES5.types b/tests/baselines/reference/newWithSpreadES5.types index dfa45b33ee1..ce173e071d8 100644 --- a/tests/baselines/reference/newWithSpreadES5.types +++ b/tests/baselines/reference/newWithSpreadES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts === - function f(x: number, y: number, ...z: string[]) { >f : (x: number, y: number, ...z: string[]) => void >x : number diff --git a/tests/baselines/reference/newWithSpreadES6.js b/tests/baselines/reference/newWithSpreadES6.js index dca5264cb3f..ab9c17d5d66 100644 --- a/tests/baselines/reference/newWithSpreadES6.js +++ b/tests/baselines/reference/newWithSpreadES6.js @@ -1,5 +1,4 @@ //// [newWithSpreadES6.ts] - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpreadES6.symbols b/tests/baselines/reference/newWithSpreadES6.symbols index 946aeeb5c1a..98c58e40451 100644 --- a/tests/baselines/reference/newWithSpreadES6.symbols +++ b/tests/baselines/reference/newWithSpreadES6.symbols @@ -1,85 +1,84 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts === - function f(x: number, y: number, ...z: string[]) { >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->x : Symbol(x, Decl(newWithSpreadES6.ts, 1, 11)) ->y : Symbol(y, Decl(newWithSpreadES6.ts, 1, 21)) ->z : Symbol(z, Decl(newWithSpreadES6.ts, 1, 32)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 0, 11)) +>y : Symbol(y, Decl(newWithSpreadES6.ts, 0, 21)) +>z : Symbol(z, Decl(newWithSpreadES6.ts, 0, 32)) } function f2(...x: string[]) { ->f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 2, 1)) ->x : Symbol(x, Decl(newWithSpreadES6.ts, 4, 12)) +>f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 1, 1)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 3, 12)) } interface A { ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) f: { ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new (x: number, y: number, ...z: string[]); ->x : Symbol(x, Decl(newWithSpreadES6.ts, 9, 13)) ->y : Symbol(y, Decl(newWithSpreadES6.ts, 9, 23)) ->z : Symbol(z, Decl(newWithSpreadES6.ts, 9, 34)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 8, 13)) +>y : Symbol(y, Decl(newWithSpreadES6.ts, 8, 23)) +>z : Symbol(z, Decl(newWithSpreadES6.ts, 8, 34)) } } class B { ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) constructor(x: number, y: number, ...z: string[]) {} ->x : Symbol(x, Decl(newWithSpreadES6.ts, 14, 16)) ->y : Symbol(y, Decl(newWithSpreadES6.ts, 14, 26)) ->z : Symbol(z, Decl(newWithSpreadES6.ts, 14, 37)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 13, 16)) +>y : Symbol(y, Decl(newWithSpreadES6.ts, 13, 26)) +>z : Symbol(z, Decl(newWithSpreadES6.ts, 13, 37)) } interface C { ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) "a-b": typeof B; ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) } interface D { ->D : Symbol(D, Decl(newWithSpreadES6.ts, 19, 1)) +>D : Symbol(D, Decl(newWithSpreadES6.ts, 18, 1)) 1: typeof B; ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) } var a: string[]; ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) var b: A; ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) var c: C; ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) var d: A[]; ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) var e: { [key: string]: A }; ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->key : Symbol(key, Decl(newWithSpreadES6.ts, 29, 10)) ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>key : Symbol(key, Decl(newWithSpreadES6.ts, 28, 10)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) var g: C[]; ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) var h: { [key: string]: C }; ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->key : Symbol(key, Decl(newWithSpreadES6.ts, 31, 10)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>key : Symbol(key, Decl(newWithSpreadES6.ts, 30, 10)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) var i: C[][]; ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) // Basic expression new f(1, 2, "string"); @@ -87,22 +86,22 @@ new f(1, 2, "string"); new f(1, 2, ...a); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new f(1, 2, ...a, "string"); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Multiple spreads arguments new f2(...a, ...a); ->f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 2, 1)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 1, 1)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new f(1 ,2, ...a, ...a); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Call expression new f(1, 2, "string")(); @@ -110,165 +109,165 @@ new f(1, 2, "string")(); new f(1, 2, ...a)(); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new f(1, 2, ...a, "string")(); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Property access expression new b.f(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new b.f(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new b.f(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Parenthesised expression new (b.f)(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new (b.f)(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new (b.f)(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression new d[1].f(1, 2, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new d[1].f(1, 2, ...a); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new d[1].f(1, 2, ...a, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression with a punctuated key new e["a-b"].f(1, 2, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new e["a-b"].f(1, 2, ...a); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new e["a-b"].f(1, 2, ...a, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Basic expression new B(1, 2, "string"); ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) new B(1, 2, ...a); ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new B(1, 2, ...a, "string"); ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Property access expression new c["a-b"](1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new c["a-b"](1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new c["a-b"](1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Parenthesised expression new (c["a-b"])(1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new (c["a-b"])(1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new (c["a-b"])(1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression new g[1]["a-b"](1, 2, "string"); ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new g[1]["a-b"](1, 2, ...a); ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new g[1]["a-b"](1, 2, ...a, "string"); ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression with a punctuated key new h["a-b"]["a-b"](1, 2, "string"); ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new h["a-b"]["a-b"](1, 2, ...a); ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new h["a-b"]["a-b"](1, 2, ...a, "string"); ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression with a number new i["a-b"][1](1, 2, "string"); ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) new i["a-b"][1](1, 2, ...a); ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new i["a-b"][1](1, 2, ...a, "string"); ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) diff --git a/tests/baselines/reference/newWithSpreadES6.types b/tests/baselines/reference/newWithSpreadES6.types index 587e7683e6a..8567d04f260 100644 --- a/tests/baselines/reference/newWithSpreadES6.types +++ b/tests/baselines/reference/newWithSpreadES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts === - function f(x: number, y: number, ...z: string[]) { >f : (x: number, y: number, ...z: string[]) => void >x : number diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.js b/tests/baselines/reference/noBundledEmitFromNodeModules.js index 67216a408af..b52a7ff9a37 100644 --- a/tests/baselines/reference/noBundledEmitFromNodeModules.js +++ b/tests/baselines/reference/noBundledEmitFromNodeModules.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/noBundledEmitFromNodeModules.ts] //// //// [index.ts] - export class C {} //// [a.ts] diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.symbols b/tests/baselines/reference/noBundledEmitFromNodeModules.symbols index a1f6c67e4b4..d82770274d9 100644 --- a/tests/baselines/reference/noBundledEmitFromNodeModules.symbols +++ b/tests/baselines/reference/noBundledEmitFromNodeModules.symbols @@ -3,7 +3,6 @@ import { C } from "projB"; >C : Symbol(C, Decl(a.ts, 0, 8)) === /node_modules/projB/index.ts === - export class C {} >C : Symbol(C, Decl(index.ts, 0, 0)) diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.types b/tests/baselines/reference/noBundledEmitFromNodeModules.types index a11bad24aaf..3c598921ee4 100644 --- a/tests/baselines/reference/noBundledEmitFromNodeModules.types +++ b/tests/baselines/reference/noBundledEmitFromNodeModules.types @@ -3,7 +3,6 @@ import { C } from "projB"; >C : typeof C === /node_modules/projB/index.ts === - export class C {} >C : C diff --git a/tests/baselines/reference/noCatchBlock.js b/tests/baselines/reference/noCatchBlock.js index ecc9c7f8c7e..ef9ff6cb1de 100644 --- a/tests/baselines/reference/noCatchBlock.js +++ b/tests/baselines/reference/noCatchBlock.js @@ -1,5 +1,4 @@ //// [noCatchBlock.ts] - try { // ... } finally { diff --git a/tests/baselines/reference/noCatchBlock.js.map b/tests/baselines/reference/noCatchBlock.js.map index 392ec588108..9e3da66cb31 100644 --- a/tests/baselines/reference/noCatchBlock.js.map +++ b/tests/baselines/reference/noCatchBlock.js.map @@ -1,2 +1,2 @@ //// [noCatchBlock.js.map] -{"version":3,"file":"noCatchBlock.js","sourceRoot":"","sources":["noCatchBlock.ts"],"names":[],"mappings":"AACA,IAAI,CAAC;IACJ,MAAM;AACP,CAAC;QAAS,CAAC;IACV,wBAAwB;AACzB,CAAC"} \ No newline at end of file +{"version":3,"file":"noCatchBlock.js","sourceRoot":"","sources":["noCatchBlock.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC;IACJ,MAAM;AACP,CAAC;QAAS,CAAC;IACV,wBAAwB;AACzB,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/noCatchBlock.sourcemap.txt b/tests/baselines/reference/noCatchBlock.sourcemap.txt index 5210f12d734..455d0538d65 100644 --- a/tests/baselines/reference/noCatchBlock.sourcemap.txt +++ b/tests/baselines/reference/noCatchBlock.sourcemap.txt @@ -13,13 +13,12 @@ sourceFile:noCatchBlock.ts 2 >^^^^ 3 > ^ 4 > ^^^^^^-> -1 > - > +1 > 2 >try 3 > { -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) --- >>> // ... 1->^^^^ @@ -27,8 +26,8 @@ sourceFile:noCatchBlock.ts 1-> > 2 > // ... -1->Emitted(2, 5) Source(3, 2) + SourceIndex(0) -2 >Emitted(2, 11) Source(3, 8) + SourceIndex(0) +1->Emitted(2, 5) Source(2, 2) + SourceIndex(0) +2 >Emitted(2, 11) Source(2, 8) + SourceIndex(0) --- >>>} 1 > @@ -37,8 +36,8 @@ sourceFile:noCatchBlock.ts 1 > > 2 >} -1 >Emitted(3, 1) Source(4, 1) + SourceIndex(0) -2 >Emitted(3, 2) Source(4, 2) + SourceIndex(0) +1 >Emitted(3, 1) Source(3, 1) + SourceIndex(0) +2 >Emitted(3, 2) Source(3, 2) + SourceIndex(0) --- >>>finally { 1->^^^^^^^^ @@ -46,8 +45,8 @@ sourceFile:noCatchBlock.ts 3 > ^^^^^^^^^^^^^^^^^^^^-> 1-> finally 2 > { -1->Emitted(4, 9) Source(4, 11) + SourceIndex(0) -2 >Emitted(4, 10) Source(4, 12) + SourceIndex(0) +1->Emitted(4, 9) Source(3, 11) + SourceIndex(0) +2 >Emitted(4, 10) Source(3, 12) + SourceIndex(0) --- >>> // N.B. No 'catch' block 1->^^^^ @@ -55,8 +54,8 @@ sourceFile:noCatchBlock.ts 1-> > 2 > // N.B. No 'catch' block -1->Emitted(5, 5) Source(5, 2) + SourceIndex(0) -2 >Emitted(5, 29) Source(5, 26) + SourceIndex(0) +1->Emitted(5, 5) Source(4, 2) + SourceIndex(0) +2 >Emitted(5, 29) Source(4, 26) + SourceIndex(0) --- >>>} 1 > @@ -65,7 +64,7 @@ sourceFile:noCatchBlock.ts 1 > > 2 >} -1 >Emitted(6, 1) Source(6, 1) + SourceIndex(0) -2 >Emitted(6, 2) Source(6, 2) + SourceIndex(0) +1 >Emitted(6, 1) Source(5, 1) + SourceIndex(0) +2 >Emitted(6, 2) Source(5, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=noCatchBlock.js.map \ No newline at end of file diff --git a/tests/baselines/reference/noCatchBlock.symbols b/tests/baselines/reference/noCatchBlock.symbols index cf7689660a3..655d90f047b 100644 --- a/tests/baselines/reference/noCatchBlock.symbols +++ b/tests/baselines/reference/noCatchBlock.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/noCatchBlock.ts === - -No type information for this code.try { +try { No type information for this code. // ... No type information for this code.} finally { No type information for this code. // N.B. No 'catch' block diff --git a/tests/baselines/reference/noCatchBlock.types b/tests/baselines/reference/noCatchBlock.types index cf7689660a3..655d90f047b 100644 --- a/tests/baselines/reference/noCatchBlock.types +++ b/tests/baselines/reference/noCatchBlock.types @@ -1,6 +1,5 @@ === tests/cases/compiler/noCatchBlock.ts === - -No type information for this code.try { +try { No type information for this code. // ... No type information for this code.} finally { No type information for this code. // N.B. No 'catch' block diff --git a/tests/baselines/reference/noEmitHelpers.js b/tests/baselines/reference/noEmitHelpers.js index 1a9ad2579b9..b8dfcf7377e 100644 --- a/tests/baselines/reference/noEmitHelpers.js +++ b/tests/baselines/reference/noEmitHelpers.js @@ -1,5 +1,4 @@ //// [noEmitHelpers.ts] - class A { } class B extends A { } diff --git a/tests/baselines/reference/noEmitHelpers.symbols b/tests/baselines/reference/noEmitHelpers.symbols index 654f1a6cad5..cab13146cb2 100644 --- a/tests/baselines/reference/noEmitHelpers.symbols +++ b/tests/baselines/reference/noEmitHelpers.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/noEmitHelpers.ts === - class A { } >A : Symbol(A, Decl(noEmitHelpers.ts, 0, 0)) class B extends A { } ->B : Symbol(B, Decl(noEmitHelpers.ts, 1, 11)) +>B : Symbol(B, Decl(noEmitHelpers.ts, 0, 11)) >A : Symbol(A, Decl(noEmitHelpers.ts, 0, 0)) diff --git a/tests/baselines/reference/noEmitHelpers.types b/tests/baselines/reference/noEmitHelpers.types index 01c5d5acb3d..d39497d1983 100644 --- a/tests/baselines/reference/noEmitHelpers.types +++ b/tests/baselines/reference/noEmitHelpers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noEmitHelpers.ts === - class A { } >A : A diff --git a/tests/baselines/reference/noEmitHelpers2.js b/tests/baselines/reference/noEmitHelpers2.js index 64acadf07e3..44ab7900005 100644 --- a/tests/baselines/reference/noEmitHelpers2.js +++ b/tests/baselines/reference/noEmitHelpers2.js @@ -1,5 +1,4 @@ //// [noEmitHelpers2.ts] - declare var decorator: any; @decorator diff --git a/tests/baselines/reference/noEmitHelpers2.symbols b/tests/baselines/reference/noEmitHelpers2.symbols index 044026a3db7..366a2828151 100644 --- a/tests/baselines/reference/noEmitHelpers2.symbols +++ b/tests/baselines/reference/noEmitHelpers2.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/noEmitHelpers2.ts === - declare var decorator: any; ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 11)) @decorator ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 11)) class A { ->A : Symbol(A, Decl(noEmitHelpers2.ts, 1, 27)) +>A : Symbol(A, Decl(noEmitHelpers2.ts, 0, 27)) constructor(a: number, @decorator b: string) { ->a : Symbol(a, Decl(noEmitHelpers2.ts, 5, 16)) ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) ->b : Symbol(b, Decl(noEmitHelpers2.ts, 5, 26)) +>a : Symbol(a, Decl(noEmitHelpers2.ts, 4, 16)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 11)) +>b : Symbol(b, Decl(noEmitHelpers2.ts, 4, 26)) } } diff --git a/tests/baselines/reference/noEmitHelpers2.types b/tests/baselines/reference/noEmitHelpers2.types index 14260e4f95c..9f2adc81327 100644 --- a/tests/baselines/reference/noEmitHelpers2.types +++ b/tests/baselines/reference/noEmitHelpers2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noEmitHelpers2.ts === - declare var decorator: any; >decorator : any diff --git a/tests/baselines/reference/noEmitOnError.errors.txt b/tests/baselines/reference/noEmitOnError.errors.txt index 87a71c30756..6262fa760f0 100644 --- a/tests/baselines/reference/noEmitOnError.errors.txt +++ b/tests/baselines/reference/noEmitOnError.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noEmitOnError.ts(2,5): error TS2322: Type '""' is not assignable to type 'number'. +tests/cases/compiler/noEmitOnError.ts(1,5): error TS2322: Type '""' is not assignable to type 'number'. ==== tests/cases/compiler/noEmitOnError.ts (1 errors) ==== - var x: number = ""; ~ !!! error TS2322: Type '""' is not assignable to type 'number'. diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols index d3d338e0d14..d3d9ab83ea8 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/0.d.ts === - export = a; ->a : Symbol(a, Decl(0.d.ts, 2, 11)) +>a : Symbol(a, Decl(0.d.ts, 1, 11)) declare var a: number; ->a : Symbol(a, Decl(0.d.ts, 2, 11)) +>a : Symbol(a, Decl(0.d.ts, 1, 11)) diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types index c5e2c0b80f8..37092f98088 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.d.ts === - export = a; >a : number diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt index bcf5d91c015..b9130255e13 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/1.ts(2,1): error TS1148: Cannot use imports, exports, or module augmentations when '--module' is 'none'. +tests/cases/compiler/1.ts(1,1): error TS1148: Cannot use imports, exports, or module augmentations when '--module' is 'none'. ==== tests/cases/compiler/1.ts (1 errors) ==== - export var j = "hello"; // error ~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS1148: Cannot use imports, exports, or module augmentations when '--module' is 'none'. diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js index 1e2231868a8..fc778fbda09 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.ts] //// //// [1.ts] - export var j = "hello"; // error //// [0.d.ts] diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt index eb215693cd7..85ad46de437 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/1.ts(1,1): error TS1148: Cannot use imports, exports, or mo ==== tests/cases/compiler/0.d.ts (0 errors) ==== - export = a; declare var a: number; diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js index f651d4f5b18..b97e6e306d7 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.ts] //// //// [0.d.ts] - export = a; declare var a: number; diff --git a/tests/baselines/reference/noImplicitAnyForIn.errors.txt b/tests/baselines/reference/noImplicitAnyForIn.errors.txt index 3db1c260d51..b384735d82e 100644 --- a/tests/baselines/reference/noImplicitAnyForIn.errors.txt +++ b/tests/baselines/reference/noImplicitAnyForIn.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyForIn.ts(8,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyForIn.ts(15,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyForIn.ts(29,5): error TS7005: Variable 'n' implicitly has an 'any[][]' type. -tests/cases/compiler/noImplicitAnyForIn.ts(31,6): error TS2405: The left-hand side of a 'for...in' statement must be of type 'string' or 'any'. +tests/cases/compiler/noImplicitAnyForIn.ts(7,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyForIn.ts(14,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyForIn.ts(28,5): error TS7005: Variable 'n' implicitly has an 'any[][]' type. +tests/cases/compiler/noImplicitAnyForIn.ts(30,6): error TS2405: The left-hand side of a 'for...in' statement must be of type 'string' or 'any'. ==== tests/cases/compiler/noImplicitAnyForIn.ts (4 errors) ==== - var x: {}[] = [[1, 2, 3], ["hello"]]; for (var i in x) { diff --git a/tests/baselines/reference/noImplicitAnyForIn.js b/tests/baselines/reference/noImplicitAnyForIn.js index c8743936a9a..39dbb77e5e7 100644 --- a/tests/baselines/reference/noImplicitAnyForIn.js +++ b/tests/baselines/reference/noImplicitAnyForIn.js @@ -1,5 +1,4 @@ //// [noImplicitAnyForIn.ts] - var x: {}[] = [[1, 2, 3], ["hello"]]; for (var i in x) { diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js index 568d94c53ba..ac8e037d1c0 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js @@ -1,5 +1,4 @@ //// [noImplicitAnyFunctionExpressionAssignment.ts] - var x: (a: any) => void = function (x: T) { return null; }; diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols index 8e9a331a205..6e1bb888b41 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts === - var x: (a: any) => void = function (x: T) { ->x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 3)) ->a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 8)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36)) ->x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 39)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36)) +>x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 3)) +>a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 8)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 36)) +>x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 39)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 36)) return null; }; var x2: (a: any) => void = function f(x: T) { ->x2 : Symbol(x2, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 3)) ->a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 9)) ->f : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 26)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 38)) ->x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 41)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 38)) +>x2 : Symbol(x2, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 3)) +>a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 9)) +>f : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 26)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 38)) +>x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 41)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 38)) return null; }; diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types index 9d8e216b656..18b61aaf8e3 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts === - var x: (a: any) => void = function (x: T) { >x : (a: any) => void >a : any diff --git a/tests/baselines/reference/noImplicitAnyFunctions.errors.txt b/tests/baselines/reference/noImplicitAnyFunctions.errors.txt index 158690deef0..88185102a4a 100644 --- a/tests/baselines/reference/noImplicitAnyFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitAnyFunctions.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/noImplicitAnyFunctions.ts(2,18): error TS7010: 'f1', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyFunctions.ts(6,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyFunctions.ts(17,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyFunctions.ts(19,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyFunctions.ts(19,24): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyFunctions.ts(1,18): error TS7010: 'f1', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyFunctions.ts(5,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyFunctions.ts(16,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyFunctions.ts(18,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyFunctions.ts(18,24): error TS7006: Parameter 'y' implicitly has an 'any' type. ==== tests/cases/compiler/noImplicitAnyFunctions.ts (5 errors) ==== - declare function f1(); ~~ !!! error TS7010: 'f1', which lacks return-type annotation, implicitly has an 'any' return type. diff --git a/tests/baselines/reference/noImplicitAnyFunctions.js b/tests/baselines/reference/noImplicitAnyFunctions.js index 57998188d9e..369a6f71044 100644 --- a/tests/baselines/reference/noImplicitAnyFunctions.js +++ b/tests/baselines/reference/noImplicitAnyFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitAnyFunctions.ts] - declare function f1(); declare function f2(): any; diff --git a/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt b/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt index eb379c67026..01c8e4ee6c5 100644 --- a/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt +++ b/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitAnyInBareInterface.ts(4,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyInBareInterface.ts(6,5): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyInBareInterface.ts(3,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyInBareInterface.ts(5,5): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/compiler/noImplicitAnyInBareInterface.ts (2 errors) ==== - interface Entry { // Should return error for implicit any on `new` and `foo`. new (); diff --git a/tests/baselines/reference/noImplicitAnyInBareInterface.js b/tests/baselines/reference/noImplicitAnyInBareInterface.js index 0a3bbe1bb8e..817e137ce09 100644 --- a/tests/baselines/reference/noImplicitAnyInBareInterface.js +++ b/tests/baselines/reference/noImplicitAnyInBareInterface.js @@ -1,5 +1,4 @@ //// [noImplicitAnyInBareInterface.ts] - interface Entry { // Should return error for implicit any on `new` and `foo`. new (); diff --git a/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt b/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt index 8243a9c68ce..769353b9965 100644 --- a/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt +++ b/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitAnyInCastExpression.ts(16,2): error TS2352: Type '{ c: null; }' cannot be converted to type 'IFoo'. +tests/cases/compiler/noImplicitAnyInCastExpression.ts(15,2): error TS2352: Type '{ c: null; }' cannot be converted to type 'IFoo'. Property 'a' is missing in type '{ c: null; }'. ==== tests/cases/compiler/noImplicitAnyInCastExpression.ts (1 errors) ==== - // verify no noImplictAny errors reported with cast expression interface IFoo { diff --git a/tests/baselines/reference/noImplicitAnyInCastExpression.js b/tests/baselines/reference/noImplicitAnyInCastExpression.js index b0a6907a5b4..cb84e3f7701 100644 --- a/tests/baselines/reference/noImplicitAnyInCastExpression.js +++ b/tests/baselines/reference/noImplicitAnyInCastExpression.js @@ -1,5 +1,4 @@ //// [noImplicitAnyInCastExpression.ts] - // verify no noImplictAny errors reported with cast expression interface IFoo { diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js index 7722165fd23..e6a3d084ea5 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js @@ -1,5 +1,4 @@ //// [noImplicitAnyInContextuallyTypesFunctionParamter.ts] - var regexMatchList = ['', '']; regexMatchList.forEach(match => ''.replace(match, '')); diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols index 6cee1604cf0..f203e8af41d 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/noImplicitAnyInContextuallyTypesFunctionParamter.ts === - var regexMatchList = ['', '']; ->regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3)) +>regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 0, 3)) regexMatchList.forEach(match => ''.replace(match, '')); >regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) ->regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3)) +>regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 0, 3)) >forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) ->match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23)) +>match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 23)) >''.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23)) +>match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 23)) diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types index 928185a0953..5e5d5c20173 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitAnyInContextuallyTypesFunctionParamter.ts === - var regexMatchList = ['', '']; >regexMatchList : string[] >['', ''] : string[] diff --git a/tests/baselines/reference/noImplicitAnyIndexing.errors.txt b/tests/baselines/reference/noImplicitAnyIndexing.errors.txt index 3274bec5aae..8d1d3ea6c46 100644 --- a/tests/baselines/reference/noImplicitAnyIndexing.errors.txt +++ b/tests/baselines/reference/noImplicitAnyIndexing.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyIndexing.ts(13,37): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. -tests/cases/compiler/noImplicitAnyIndexing.ts(20,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyIndexing.ts(23,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyIndexing.ts(31,10): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyIndexing.ts(12,37): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. +tests/cases/compiler/noImplicitAnyIndexing.ts(19,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyIndexing.ts(22,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyIndexing.ts(30,10): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. ==== tests/cases/compiler/noImplicitAnyIndexing.ts (4 errors) ==== - enum MyEmusEnum { emu } diff --git a/tests/baselines/reference/noImplicitAnyIndexing.js b/tests/baselines/reference/noImplicitAnyIndexing.js index 8451a1426a6..2fe60873e61 100644 --- a/tests/baselines/reference/noImplicitAnyIndexing.js +++ b/tests/baselines/reference/noImplicitAnyIndexing.js @@ -1,5 +1,4 @@ //// [noImplicitAnyIndexing.ts] - enum MyEmusEnum { emu } diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js index 6d91d8eb838..7d871d83217 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js @@ -1,5 +1,4 @@ //// [noImplicitAnyIndexingSuppressed.ts] - enum MyEmusEnum { emu } diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols index 96b38408560..d97a59cf091 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols @@ -1,74 +1,73 @@ === tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts === - enum MyEmusEnum { >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) emu ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) } // Should be okay; should be a string. var strRepresentation1 = MyEmusEnum[0] ->strRepresentation1 : Symbol(strRepresentation1, Decl(noImplicitAnyIndexingSuppressed.ts, 6, 3)) +>strRepresentation1 : Symbol(strRepresentation1, Decl(noImplicitAnyIndexingSuppressed.ts, 5, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) // Should be okay; should be a string. var strRepresentation2 = MyEmusEnum[MyEmusEnum.emu] ->strRepresentation2 : Symbol(strRepresentation2, Decl(noImplicitAnyIndexingSuppressed.ts, 9, 3)) +>strRepresentation2 : Symbol(strRepresentation2, Decl(noImplicitAnyIndexingSuppressed.ts, 8, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) // Should be okay, as we suppress implicit 'any' property access checks var strRepresentation3 = MyEmusEnum["monehh"]; ->strRepresentation3 : Symbol(strRepresentation3, Decl(noImplicitAnyIndexingSuppressed.ts, 12, 3)) +>strRepresentation3 : Symbol(strRepresentation3, Decl(noImplicitAnyIndexingSuppressed.ts, 11, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) // Should be okay; should be a MyEmusEnum var strRepresentation4 = MyEmusEnum["emu"]; ->strRepresentation4 : Symbol(strRepresentation4, Decl(noImplicitAnyIndexingSuppressed.ts, 15, 3)) +>strRepresentation4 : Symbol(strRepresentation4, Decl(noImplicitAnyIndexingSuppressed.ts, 14, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->"emu" : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>"emu" : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) // Should be okay, as we suppress implicit 'any' property access checks var x = {}["hi"]; ->x : Symbol(x, Decl(noImplicitAnyIndexingSuppressed.ts, 19, 3)) +>x : Symbol(x, Decl(noImplicitAnyIndexingSuppressed.ts, 18, 3)) // Should be okay, as we suppress implicit 'any' property access checks var y = {}[10]; ->y : Symbol(y, Decl(noImplicitAnyIndexingSuppressed.ts, 22, 3)) +>y : Symbol(y, Decl(noImplicitAnyIndexingSuppressed.ts, 21, 3)) var hi: any = "hi"; ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) var emptyObj = {}; ->emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3)) +>emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 25, 3)) // Should be okay, as we suppress implicit 'any' property access checks var z1 = emptyObj[hi]; ->z1 : Symbol(z1, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 3)) ->emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3)) ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>z1 : Symbol(z1, Decl(noImplicitAnyIndexingSuppressed.ts, 28, 3)) +>emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 25, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) var z2 = (emptyObj)[hi]; ->z2 : Symbol(z2, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 3)) ->emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3)) ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>z2 : Symbol(z2, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 3)) +>emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 25, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) interface MyMap { ->MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 29)) ->T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 32, 16)) +>MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 29)) +>T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 31, 16)) [key: string]: T; ->key : Symbol(key, Decl(noImplicitAnyIndexingSuppressed.ts, 33, 5)) ->T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 32, 16)) +>key : Symbol(key, Decl(noImplicitAnyIndexingSuppressed.ts, 32, 5)) +>T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 31, 16)) } var m: MyMap = { ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) ->MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 29)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) +>MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 29)) "0": 0, "1": 1, @@ -79,23 +78,23 @@ var m: MyMap = { }; var mResult1 = m[MyEmusEnum.emu]; ->mResult1 : Symbol(mResult1, Decl(noImplicitAnyIndexingSuppressed.ts, 43, 3)) ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) ->MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>mResult1 : Symbol(mResult1, Decl(noImplicitAnyIndexingSuppressed.ts, 42, 3)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) +>MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) var mResult2 = m[MyEmusEnum[MyEmusEnum.emu]]; ->mResult2 : Symbol(mResult2, Decl(noImplicitAnyIndexingSuppressed.ts, 44, 3)) ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) +>mResult2 : Symbol(mResult2, Decl(noImplicitAnyIndexingSuppressed.ts, 43, 3)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) var mResult3 = m[hi]; ->mResult3 : Symbol(mResult3, Decl(noImplicitAnyIndexingSuppressed.ts, 45, 3)) ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>mResult3 : Symbol(mResult3, Decl(noImplicitAnyIndexingSuppressed.ts, 44, 3)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types index 6bb0c04fbb0..18c10871cf0 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts === - enum MyEmusEnum { >MyEmusEnum : MyEmusEnum diff --git a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt index ef2a273711f..434058d13a4 100644 --- a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt +++ b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(4,25): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(4,33): error TS7006: Parameter 'str' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(9,16): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(9,24): error TS7006: Parameter 'str' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(3,25): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(3,33): error TS7006: Parameter 'str' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(8,16): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(8,24): error TS7006: Parameter 'str' implicitly has an 'any' type. ==== tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts (4 errors) ==== - abstract class Parent { public abstract set message(str); diff --git a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js index 7dc7e4dafb3..12b6501e26a 100644 --- a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js +++ b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js @@ -1,5 +1,4 @@ //// [noImplicitAnyMissingGetAccessor.ts] - abstract class Parent { public abstract set message(str); diff --git a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt index ba104209189..4e69b22aab5 100644 --- a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt +++ b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noImplicitAnyMissingSetAccessor.ts(4,25): error TS7033: Property 'message' implicitly has type 'any', because its get accessor lacks a return type annotation. +tests/cases/compiler/noImplicitAnyMissingSetAccessor.ts(3,25): error TS7033: Property 'message' implicitly has type 'any', because its get accessor lacks a return type annotation. ==== tests/cases/compiler/noImplicitAnyMissingSetAccessor.ts (1 errors) ==== - abstract class Parent { public abstract get message(); diff --git a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js index 31d7e65ed9b..a5ef6bfc1f4 100644 --- a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js +++ b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js @@ -1,5 +1,4 @@ //// [noImplicitAnyMissingSetAccessor.ts] - abstract class Parent { public abstract get message(); diff --git a/tests/baselines/reference/noImplicitAnyModule.errors.txt b/tests/baselines/reference/noImplicitAnyModule.errors.txt index 35c0993df3e..131486655d6 100644 --- a/tests/baselines/reference/noImplicitAnyModule.errors.txt +++ b/tests/baselines/reference/noImplicitAnyModule.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyModule.ts(5,9): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyModule.ts(10,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyModule.ts(11,16): error TS7010: 'g', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyModule.ts(18,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyModule.ts(4,9): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyModule.ts(9,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyModule.ts(10,16): error TS7010: 'g', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyModule.ts(17,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/compiler/noImplicitAnyModule.ts (4 errors) ==== - declare module Module { interface Interface { // Should return error for implicit any on return type. diff --git a/tests/baselines/reference/noImplicitAnyModule.js b/tests/baselines/reference/noImplicitAnyModule.js index 9ce7309e370..7d490b8b3c7 100644 --- a/tests/baselines/reference/noImplicitAnyModule.js +++ b/tests/baselines/reference/noImplicitAnyModule.js @@ -1,5 +1,4 @@ //// [noImplicitAnyModule.ts] - declare module Module { interface Interface { // Should return error for implicit any on return type. diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt index a2ac9467856..0d308e92557 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt @@ -1,38 +1,37 @@ -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(13,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(13,22): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(13,25): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(16,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(16,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(19,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(22,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(22,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(25,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(26,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(27,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(27,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(33,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(36,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(36,25): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(36,28): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(39,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(39,33): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(42,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(45,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(45,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(79,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(82,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(82,27): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(82,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(85,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(85,35): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(88,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(91,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(91,27): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(12,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(12,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(12,25): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(15,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(15,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(18,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(21,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(21,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(24,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(25,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(26,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(26,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(32,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(35,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(35,25): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(35,28): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(38,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(38,33): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(41,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(44,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(44,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(78,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(81,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(81,27): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(81,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(84,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(84,35): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(87,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(90,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(90,27): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts (31 errors) ==== - declare class D_C { // No implicit-'any' errors. public pub_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js index 4af0a8c74a3..9e92ac9ecc5 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInAmbientClass.ts] - declare class D_C { // No implicit-'any' errors. public pub_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt index 37af83d7891..fd9b3ac4053 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(6,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(12,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(12,26): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(12,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(15,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(15,34): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(18,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(21,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(21,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(24,23): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(25,35): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(26,23): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(26,27): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(32,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(35,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(35,24): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(35,27): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(38,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(38,32): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(41,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(44,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(44,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(5,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(11,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(11,26): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(11,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(14,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(14,34): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(17,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(20,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(20,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(23,23): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(24,35): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(25,23): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(25,27): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(31,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(34,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(34,24): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(34,27): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(37,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(37,32): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(40,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(43,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(43,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts (22 errors) ==== - // No implicit-'any' errors. declare function d_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js index 3e825c2b24f..aa8f2bd8bb3 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInAmbientFunctions.ts] - // No implicit-'any' errors. declare function d_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt index 7bdfbcaae88..04720e3a8b9 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(7,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(13,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(13,23): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(13,26): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(16,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(16,31): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(19,20): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(22,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(22,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(25,20): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(26,32): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(27,20): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(27,24): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(33,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(36,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(36,21): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(36,24): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(39,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(39,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(42,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(45,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(45,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(6,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(12,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(12,23): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(12,26): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(15,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(15,31): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(18,20): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(21,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(21,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(24,20): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(25,32): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(26,20): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(26,24): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(32,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(35,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(35,21): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(35,24): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(38,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(38,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(41,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(44,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(44,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts (22 errors) ==== - declare module D_M { // No implicit-'any' errors. function dm_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js index d35cbe9d9d4..51788b62dc1 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInAmbientModule.ts] - declare module D_M { // No implicit-'any' errors. function dm_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt index 3d3cc1aa5ea..859f50708ea 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(6,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(12,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(12,16): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(12,19): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(15,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(15,24): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(18,13): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(21,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(21,16): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(24,13): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(25,25): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(26,13): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(26,17): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(32,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(35,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(35,15): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(35,18): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(38,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(38,23): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(41,12): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(44,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(44,15): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(5,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(11,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(11,16): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(11,19): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(14,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(14,24): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(17,13): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(20,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(20,16): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(23,13): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(24,25): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(25,13): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(25,17): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(31,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(34,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(34,15): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(34,18): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(37,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(37,23): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(40,12): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(43,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(43,15): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts (22 errors) ==== - // No implicit-'any' errors. function f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js index 3b0b630b537..4371a608799 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js +++ b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInBareFunctions.ts] - // No implicit-'any' errors. function f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt index 98d743a21aa..2e9041f5c51 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt @@ -1,51 +1,50 @@ -tests/cases/compiler/noImplicitAnyParametersInClass.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(13,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(13,22): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(13,25): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(16,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(16,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(19,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(22,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(22,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(25,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(26,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(27,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(27,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(33,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(36,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(36,26): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(36,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(39,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(39,34): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(42,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(45,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(45,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(53,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(59,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(59,24): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(59,27): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(62,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(62,32): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(65,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(68,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(68,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(71,21): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(72,33): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(73,21): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(73,25): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(79,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(82,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(82,28): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(82,31): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(85,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(85,36): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(88,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(91,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(91,28): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(12,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(12,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(12,25): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(15,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(15,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(18,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(21,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(21,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(24,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(25,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(26,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(26,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(32,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(35,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(35,26): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(35,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(38,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(38,34): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(41,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(44,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(44,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(52,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(58,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(58,24): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(58,27): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(61,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(61,32): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(64,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(67,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(67,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(70,21): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(71,33): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(72,21): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(72,25): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(78,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(81,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(81,28): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(81,31): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(84,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(84,36): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(87,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(90,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(90,28): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInClass.ts (44 errors) ==== - class C { // No implicit-'any' errors. public pub_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInClass.js b/tests/baselines/reference/noImplicitAnyParametersInClass.js index 4ad093f56be..648f93dccdc 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInClass.js +++ b/tests/baselines/reference/noImplicitAnyParametersInClass.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInClass.ts] - class C { // No implicit-'any' errors. public pub_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt index f0b9fad3b33..a001a857b4e 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt @@ -1,34 +1,33 @@ +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(3,5): error TS7020: Call signature, which lacks return-type annotation, implicitly has an 'any' return type. tests/cases/compiler/noImplicitAnyParametersInInterface.ts(4,5): error TS7020: Call signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,5): error TS7020: Call signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,6): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(6,6): error TS7006: Parameter 'x2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(6,22): error TS7006: Parameter 'z2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(12,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(18,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(18,11): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(18,14): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(21,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(21,19): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(24,8): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(27,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(27,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(30,8): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(31,20): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(32,8): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(32,12): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(38,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(41,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(41,14): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(41,17): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(44,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(44,22): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(47,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(50,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(50,14): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(4,6): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,6): error TS7006: Parameter 'x2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,22): error TS7006: Parameter 'z2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(11,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(17,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(17,11): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(17,14): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(20,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(20,19): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(23,8): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(26,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(26,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(29,8): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(30,20): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(31,8): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(31,12): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(37,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(40,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(40,14): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(40,17): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(43,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(43,22): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(46,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(49,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(49,14): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInInterface.ts (27 errors) ==== - interface I { // Implicit-'any' errors for first two call signatures, x1, x2, z2. (); diff --git a/tests/baselines/reference/noImplicitAnyParametersInInterface.js b/tests/baselines/reference/noImplicitAnyParametersInInterface.js index e8844fa1fad..59afde51a1b 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInInterface.js +++ b/tests/baselines/reference/noImplicitAnyParametersInInterface.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInInterface.ts] - interface I { // Implicit-'any' errors for first two call signatures, x1, x2, z2. (); diff --git a/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt index 8bddee624c5..85ca9d933d3 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInModule.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(13,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(13,22): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(13,25): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(16,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(16,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(19,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(22,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(22,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(25,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(26,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(27,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(27,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(33,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(36,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(36,21): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(36,24): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(39,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(39,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(42,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(45,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(45,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(12,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(12,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(12,25): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(15,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(15,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(18,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(21,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(21,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(24,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(25,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(26,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(26,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(32,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(35,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(35,21): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(35,24): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(38,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(38,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(41,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(44,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(44,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInModule.ts (22 errors) ==== - module M { // No implicit-'any' errors. function m_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInModule.js b/tests/baselines/reference/noImplicitAnyParametersInModule.js index 1866696fe34..d34f52eaa4f 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInModule.js +++ b/tests/baselines/reference/noImplicitAnyParametersInModule.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInModule.ts] - module M { // No implicit-'any' errors. function m_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt index d782e05ca61..c3fa4eebdba 100644 --- a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt +++ b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noImplicitAnyReferencingDeclaredInterface.ts(4,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyReferencingDeclaredInterface.ts(3,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/compiler/noImplicitAnyReferencingDeclaredInterface.ts (1 errors) ==== - interface Entry { // Should return error for implicit any. new (); diff --git a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js index d688e84911c..55d13f1337d 100644 --- a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js +++ b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js @@ -1,5 +1,4 @@ //// [noImplicitAnyReferencingDeclaredInterface.ts] - interface Entry { // Should return error for implicit any. new (); diff --git a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt index c66a0a83108..8a068048f3b 100644 --- a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt +++ b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts(2,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts(1,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. ==== tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts (1 errors) ==== - var x = {}["hello"]; ~~~~~~~~~~~ !!! error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. \ No newline at end of file diff --git a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js index ab9ab1752a1..cc2309192e1 100644 --- a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js +++ b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js @@ -1,5 +1,4 @@ //// [noImplicitAnyStringIndexerOnObject.ts] - var x = {}["hello"]; //// [noImplicitAnyStringIndexerOnObject.js] diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.js b/tests/baselines/reference/noImplicitReturnsInAsync1.js index 5ab86a91d3b..e165cafe3b1 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync1.js +++ b/tests/baselines/reference/noImplicitReturnsInAsync1.js @@ -1,5 +1,4 @@ //// [noImplicitReturnsInAsync1.ts] - async function test(isError: boolean = false) { if (isError === true) { return; diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols index 58d14c2a6d0..3d8a37ff080 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols +++ b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/noImplicitReturnsInAsync1.ts === - async function test(isError: boolean = false) { >test : Symbol(test, Decl(noImplicitReturnsInAsync1.ts, 0, 0)) ->isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 1, 20)) +>isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 0, 20)) if (isError === true) { ->isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 1, 20)) +>isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 0, 20)) return; } let x = await Promise.resolve("The test is passed without an error."); ->x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 5, 7)) +>x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 4, 7)) >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.types b/tests/baselines/reference/noImplicitReturnsInAsync1.types index 19da8fdfaf4..dd468d33e6e 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync1.types +++ b/tests/baselines/reference/noImplicitReturnsInAsync1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitReturnsInAsync1.ts === - async function test(isError: boolean = false) { >test : (isError?: boolean) => Promise >isError : boolean diff --git a/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt b/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt index 83673ff518b..b8e4951e185 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt +++ b/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitReturnsInAsync2.ts(3,16): error TS7030: Not all code paths return a value. -tests/cases/compiler/noImplicitReturnsInAsync2.ts(25,48): error TS7030: Not all code paths return a value. +tests/cases/compiler/noImplicitReturnsInAsync2.ts(2,16): error TS7030: Not all code paths return a value. +tests/cases/compiler/noImplicitReturnsInAsync2.ts(24,48): error TS7030: Not all code paths return a value. ==== tests/cases/compiler/noImplicitReturnsInAsync2.ts (2 errors) ==== - // Should be an error, Promise, currently retorted correctly async function test3(isError: boolean = true) { ~~~~~ diff --git a/tests/baselines/reference/noImplicitReturnsInAsync2.js b/tests/baselines/reference/noImplicitReturnsInAsync2.js index 7e7f22bd691..e84b42e8a55 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync2.js +++ b/tests/baselines/reference/noImplicitReturnsInAsync2.js @@ -1,5 +1,4 @@ //// [noImplicitReturnsInAsync2.ts] - // Should be an error, Promise, currently retorted correctly async function test3(isError: boolean = true) { if (isError === true) { diff --git a/tests/baselines/reference/noImplicitThisFunctions.errors.txt b/tests/baselines/reference/noImplicitThisFunctions.errors.txt index 5f66ac3553f..782b752d9e4 100644 --- a/tests/baselines/reference/noImplicitThisFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitThisFunctions.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitThisFunctions.ts(14,12): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. -tests/cases/compiler/noImplicitThisFunctions.ts(18,38): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +tests/cases/compiler/noImplicitThisFunctions.ts(13,12): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +tests/cases/compiler/noImplicitThisFunctions.ts(17,38): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. ==== tests/cases/compiler/noImplicitThisFunctions.ts (2 errors) ==== - function f1(x) { // implicit any is still allowed return x + 1; diff --git a/tests/baselines/reference/noImplicitThisFunctions.js b/tests/baselines/reference/noImplicitThisFunctions.js index 80ceccbe751..c54a9cfaa8a 100644 --- a/tests/baselines/reference/noImplicitThisFunctions.js +++ b/tests/baselines/reference/noImplicitThisFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitThisFunctions.ts] - function f1(x) { // implicit any is still allowed return x + 1; diff --git a/tests/baselines/reference/noImplicitUseStrict_amd.js b/tests/baselines/reference/noImplicitUseStrict_amd.js index 387d5b9497b..b91eb949ef1 100644 --- a/tests/baselines/reference/noImplicitUseStrict_amd.js +++ b/tests/baselines/reference/noImplicitUseStrict_amd.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_amd.ts] - export var x = 0; //// [noImplicitUseStrict_amd.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_amd.symbols b/tests/baselines/reference/noImplicitUseStrict_amd.symbols index de1faa2213c..fb9e6252ceb 100644 --- a/tests/baselines/reference/noImplicitUseStrict_amd.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_amd.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_amd.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_amd.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_amd.types b/tests/baselines/reference/noImplicitUseStrict_amd.types index 5eec5bf57af..a63644347b7 100644 --- a/tests/baselines/reference/noImplicitUseStrict_amd.types +++ b/tests/baselines/reference/noImplicitUseStrict_amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_amd.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_commonjs.js b/tests/baselines/reference/noImplicitUseStrict_commonjs.js index 4b6fd2db6cd..842eae22229 100644 --- a/tests/baselines/reference/noImplicitUseStrict_commonjs.js +++ b/tests/baselines/reference/noImplicitUseStrict_commonjs.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_commonjs.ts] - export var x = 0; //// [noImplicitUseStrict_commonjs.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols b/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols index af53dc272d2..c96a624ba8d 100644 --- a/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_commonjs.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_commonjs.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_commonjs.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_commonjs.types b/tests/baselines/reference/noImplicitUseStrict_commonjs.types index ad7ed27dfe6..7f30279b6f5 100644 --- a/tests/baselines/reference/noImplicitUseStrict_commonjs.types +++ b/tests/baselines/reference/noImplicitUseStrict_commonjs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_commonjs.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_es6.js b/tests/baselines/reference/noImplicitUseStrict_es6.js index 27dbbc7ea79..badba4adf48 100644 --- a/tests/baselines/reference/noImplicitUseStrict_es6.js +++ b/tests/baselines/reference/noImplicitUseStrict_es6.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_es6.ts] - export var x = 0; //// [noImplicitUseStrict_es6.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_es6.symbols b/tests/baselines/reference/noImplicitUseStrict_es6.symbols index 31bc1904ff9..4352ee7fc27 100644 --- a/tests/baselines/reference/noImplicitUseStrict_es6.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_es6.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_es6.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_es6.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_es6.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_es6.types b/tests/baselines/reference/noImplicitUseStrict_es6.types index 38a83033ff7..d37c2ce67a3 100644 --- a/tests/baselines/reference/noImplicitUseStrict_es6.types +++ b/tests/baselines/reference/noImplicitUseStrict_es6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_es6.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_system.js b/tests/baselines/reference/noImplicitUseStrict_system.js index f1100e20fd7..a466d9b5163 100644 --- a/tests/baselines/reference/noImplicitUseStrict_system.js +++ b/tests/baselines/reference/noImplicitUseStrict_system.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_system.ts] - export var x = 0; //// [noImplicitUseStrict_system.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_system.symbols b/tests/baselines/reference/noImplicitUseStrict_system.symbols index 62b89a6593d..f002e9cebda 100644 --- a/tests/baselines/reference/noImplicitUseStrict_system.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_system.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_system.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_system.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_system.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_system.types b/tests/baselines/reference/noImplicitUseStrict_system.types index 66246719284..19165570831 100644 --- a/tests/baselines/reference/noImplicitUseStrict_system.types +++ b/tests/baselines/reference/noImplicitUseStrict_system.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_system.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_umd.js b/tests/baselines/reference/noImplicitUseStrict_umd.js index 484909c51fc..f53d6098298 100644 --- a/tests/baselines/reference/noImplicitUseStrict_umd.js +++ b/tests/baselines/reference/noImplicitUseStrict_umd.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_umd.ts] - export var x = 0; //// [noImplicitUseStrict_umd.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_umd.symbols b/tests/baselines/reference/noImplicitUseStrict_umd.symbols index a72a251ad09..1b06987a963 100644 --- a/tests/baselines/reference/noImplicitUseStrict_umd.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_umd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_umd.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_umd.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_umd.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_umd.types b/tests/baselines/reference/noImplicitUseStrict_umd.types index 102f21c238b..8e32f24af4e 100644 --- a/tests/baselines/reference/noImplicitUseStrict_umd.types +++ b/tests/baselines/reference/noImplicitUseStrict_umd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_umd.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols index 690a19ef18f..8b1adfe7938 100644 --- a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols +++ b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/test.d.ts === - declare var S: typeof A; // no error ->S : Symbol(S, Decl(test.d.ts, 1, 11)) ->A : Symbol(A, Decl(test.d.ts, 2, 13)) +>S : Symbol(S, Decl(test.d.ts, 0, 11)) +>A : Symbol(A, Decl(test.d.ts, 1, 13)) declare const A: number; ->A : Symbol(A, Decl(test.d.ts, 2, 13)) +>A : Symbol(A, Decl(test.d.ts, 1, 13)) diff --git a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types index dfacda30915..314bbf7892f 100644 --- a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types +++ b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test.d.ts === - declare var S: typeof A; // no error >S : number >A : number diff --git a/tests/baselines/reference/nodeResolution1.js b/tests/baselines/reference/nodeResolution1.js index d3dad3355e6..91f423084d8 100644 --- a/tests/baselines/reference/nodeResolution1.js +++ b/tests/baselines/reference/nodeResolution1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution1.ts] //// //// [a.ts] - export var x = 1; //// [b.ts] diff --git a/tests/baselines/reference/nodeResolution1.symbols b/tests/baselines/reference/nodeResolution1.symbols index 0cc98206e90..b5800605576 100644 --- a/tests/baselines/reference/nodeResolution1.symbols +++ b/tests/baselines/reference/nodeResolution1.symbols @@ -3,7 +3,6 @@ import y = require("./a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/a.ts === - export var x = 1; ->x : Symbol(x, Decl(a.ts, 1, 10)) +>x : Symbol(x, Decl(a.ts, 0, 10)) diff --git a/tests/baselines/reference/nodeResolution1.types b/tests/baselines/reference/nodeResolution1.types index cd4feb3aba8..350cf7a2887 100644 --- a/tests/baselines/reference/nodeResolution1.types +++ b/tests/baselines/reference/nodeResolution1.types @@ -3,7 +3,6 @@ import y = require("./a"); >y : typeof y === tests/cases/compiler/a.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nodeResolution2.js b/tests/baselines/reference/nodeResolution2.js index 6d0963c6acb..0d66b012ca7 100644 --- a/tests/baselines/reference/nodeResolution2.js +++ b/tests/baselines/reference/nodeResolution2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution2.ts] //// //// [a.d.ts] - export var x: number; //// [b.ts] diff --git a/tests/baselines/reference/nodeResolution2.symbols b/tests/baselines/reference/nodeResolution2.symbols index 643d285e7b8..ead8db27d7e 100644 --- a/tests/baselines/reference/nodeResolution2.symbols +++ b/tests/baselines/reference/nodeResolution2.symbols @@ -3,7 +3,6 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a.d.ts === - export var x: number; ->x : Symbol(x, Decl(a.d.ts, 1, 10)) +>x : Symbol(x, Decl(a.d.ts, 0, 10)) diff --git a/tests/baselines/reference/nodeResolution2.types b/tests/baselines/reference/nodeResolution2.types index 896af7f8bda..3f4e97f7cfc 100644 --- a/tests/baselines/reference/nodeResolution2.types +++ b/tests/baselines/reference/nodeResolution2.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a.d.ts === - export var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution3.js b/tests/baselines/reference/nodeResolution3.js index 8750e3ff07d..74eeec7057b 100644 --- a/tests/baselines/reference/nodeResolution3.js +++ b/tests/baselines/reference/nodeResolution3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution3.ts] //// //// [index.d.ts] - export var x: number; //// [a.ts] diff --git a/tests/baselines/reference/nodeResolution3.symbols b/tests/baselines/reference/nodeResolution3.symbols index 0fca588676f..53c85beb38d 100644 --- a/tests/baselines/reference/nodeResolution3.symbols +++ b/tests/baselines/reference/nodeResolution3.symbols @@ -3,7 +3,6 @@ import y = require("b"); >y : Symbol(y, Decl(a.ts, 0, 0)) === tests/cases/compiler/node_modules/b/index.d.ts === - export var x: number; ->x : Symbol(x, Decl(index.d.ts, 1, 10)) +>x : Symbol(x, Decl(index.d.ts, 0, 10)) diff --git a/tests/baselines/reference/nodeResolution3.types b/tests/baselines/reference/nodeResolution3.types index 82a1ccb27d3..ab6afc01f46 100644 --- a/tests/baselines/reference/nodeResolution3.types +++ b/tests/baselines/reference/nodeResolution3.types @@ -3,7 +3,6 @@ import y = require("b"); >y : typeof y === tests/cases/compiler/node_modules/b/index.d.ts === - export var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution4.js b/tests/baselines/reference/nodeResolution4.js index 0591dc5a299..3285f3b8e20 100644 --- a/tests/baselines/reference/nodeResolution4.js +++ b/tests/baselines/reference/nodeResolution4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution4.ts] //// //// [ref.ts] - var x = 1; //// [a.ts] diff --git a/tests/baselines/reference/nodeResolution4.symbols b/tests/baselines/reference/nodeResolution4.symbols index b8e0b59284a..635a158f2d6 100644 --- a/tests/baselines/reference/nodeResolution4.symbols +++ b/tests/baselines/reference/nodeResolution4.symbols @@ -3,9 +3,8 @@ import y = require("./a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/ref.ts === - var x = 1; ->x : Symbol(x, Decl(ref.ts, 1, 3)) +>x : Symbol(x, Decl(ref.ts, 0, 3)) === tests/cases/compiler/a.ts === /// diff --git a/tests/baselines/reference/nodeResolution4.types b/tests/baselines/reference/nodeResolution4.types index f52f28df25a..d73320bd9c2 100644 --- a/tests/baselines/reference/nodeResolution4.types +++ b/tests/baselines/reference/nodeResolution4.types @@ -3,7 +3,6 @@ import y = require("./a"); >y : typeof y === tests/cases/compiler/ref.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nodeResolution5.js b/tests/baselines/reference/nodeResolution5.js index f5a6165906f..3dfedea4aab 100644 --- a/tests/baselines/reference/nodeResolution5.js +++ b/tests/baselines/reference/nodeResolution5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution5.ts] //// //// [a.d.ts] - declare module "a" { var x: number; } diff --git a/tests/baselines/reference/nodeResolution5.symbols b/tests/baselines/reference/nodeResolution5.symbols index be4aa2be0e9..5871ad57a4e 100644 --- a/tests/baselines/reference/nodeResolution5.symbols +++ b/tests/baselines/reference/nodeResolution5.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a.d.ts === - declare module "a" { var x: number; ->x : Symbol(x, Decl(a.d.ts, 2, 7)) +>x : Symbol(x, Decl(a.d.ts, 1, 7)) } diff --git a/tests/baselines/reference/nodeResolution5.types b/tests/baselines/reference/nodeResolution5.types index 14f5bd24f5d..4c2872f7b5d 100644 --- a/tests/baselines/reference/nodeResolution5.types +++ b/tests/baselines/reference/nodeResolution5.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a.d.ts === - declare module "a" { var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution6.js b/tests/baselines/reference/nodeResolution6.js index cda821991d0..0610c53edcf 100644 --- a/tests/baselines/reference/nodeResolution6.js +++ b/tests/baselines/reference/nodeResolution6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution6.ts] //// //// [ref.ts] - var x = 1; //// [a.d.ts] diff --git a/tests/baselines/reference/nodeResolution6.symbols b/tests/baselines/reference/nodeResolution6.symbols index 075f94e7992..24864d15a79 100644 --- a/tests/baselines/reference/nodeResolution6.symbols +++ b/tests/baselines/reference/nodeResolution6.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/ref.ts === - var x = 1; ->x : Symbol(x, Decl(ref.ts, 1, 3)) +>x : Symbol(x, Decl(ref.ts, 0, 3)) === tests/cases/compiler/node_modules/a.d.ts === /// diff --git a/tests/baselines/reference/nodeResolution6.types b/tests/baselines/reference/nodeResolution6.types index 9e685e8c493..1c08f9c9113 100644 --- a/tests/baselines/reference/nodeResolution6.types +++ b/tests/baselines/reference/nodeResolution6.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/ref.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nodeResolution7.js b/tests/baselines/reference/nodeResolution7.js index f8cbff14726..118f9cd3994 100644 --- a/tests/baselines/reference/nodeResolution7.js +++ b/tests/baselines/reference/nodeResolution7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution7.ts] //// //// [index.d.ts] - declare module "a" { var x: number; } diff --git a/tests/baselines/reference/nodeResolution7.symbols b/tests/baselines/reference/nodeResolution7.symbols index ea8d636b61b..30b930c72e4 100644 --- a/tests/baselines/reference/nodeResolution7.symbols +++ b/tests/baselines/reference/nodeResolution7.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a/index.d.ts === - declare module "a" { var x: number; ->x : Symbol(x, Decl(index.d.ts, 2, 7)) +>x : Symbol(x, Decl(index.d.ts, 1, 7)) } diff --git a/tests/baselines/reference/nodeResolution7.types b/tests/baselines/reference/nodeResolution7.types index 1cb14150bde..8dfe6c0d15f 100644 --- a/tests/baselines/reference/nodeResolution7.types +++ b/tests/baselines/reference/nodeResolution7.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a/index.d.ts === - declare module "a" { var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution8.js b/tests/baselines/reference/nodeResolution8.js index 5facd2edc39..59a6ee67ec8 100644 --- a/tests/baselines/reference/nodeResolution8.js +++ b/tests/baselines/reference/nodeResolution8.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution8.ts] //// //// [ref.ts] - var x = 1; //// [index.d.ts] diff --git a/tests/baselines/reference/nodeResolution8.symbols b/tests/baselines/reference/nodeResolution8.symbols index 27c0941c9b9..bf698c36dfe 100644 --- a/tests/baselines/reference/nodeResolution8.symbols +++ b/tests/baselines/reference/nodeResolution8.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a/ref.ts === - var x = 1; ->x : Symbol(x, Decl(ref.ts, 1, 3)) +>x : Symbol(x, Decl(ref.ts, 0, 3)) === tests/cases/compiler/node_modules/a/index.d.ts === /// diff --git a/tests/baselines/reference/nodeResolution8.types b/tests/baselines/reference/nodeResolution8.types index 757af64a0ef..88da1e0781b 100644 --- a/tests/baselines/reference/nodeResolution8.types +++ b/tests/baselines/reference/nodeResolution8.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a/ref.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt b/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt index 473011aaa7f..6b26c4d42ac 100644 --- a/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt +++ b/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt @@ -1,29 +1,28 @@ -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(7,1): error TS2454: Variable 'a' is used before being assigned. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(8,1): error TS2322: Type 'undefined' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(9,1): error TS2322: Type 'null' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(10,1): error TS2322: Type 'object | null' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(6,1): error TS2454: Variable 'a' is used before being assigned. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(7,1): error TS2322: Type 'undefined' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(8,1): error TS2322: Type 'null' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(9,1): error TS2322: Type 'object | null' is not assignable to type 'object'. Type 'null' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(11,1): error TS2322: Type 'object | undefined' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(10,1): error TS2322: Type 'object | undefined' is not assignable to type 'object'. Type 'undefined' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(12,1): error TS2322: Type 'object | null | undefined' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(11,1): error TS2322: Type 'object | null | undefined' is not assignable to type 'object'. Type 'undefined' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(18,7): error TS2339: Property 'toString' does not exist on type 'never'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(22,5): error TS2322: Type 'object | null' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(17,7): error TS2339: Property 'toString' does not exist on type 'never'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(21,5): error TS2322: Type 'object | null' is not assignable to type 'object'. Type 'null' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(27,5): error TS2531: Object is possibly 'null'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(29,5): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(33,5): error TS2533: Object is possibly 'null' or 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(39,5): error TS2531: Object is possibly 'null'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(41,5): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(45,5): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(47,5): error TS2531: Object is possibly 'null'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(52,14): error TS2344: Type 'number' does not satisfy the constraint 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(53,14): error TS2344: Type 'null' does not satisfy the constraint 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(54,14): error TS2344: Type 'undefined' does not satisfy the constraint 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(26,5): error TS2531: Object is possibly 'null'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(28,5): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(32,5): error TS2533: Object is possibly 'null' or 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(38,5): error TS2531: Object is possibly 'null'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(40,5): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(44,5): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(46,5): error TS2531: Object is possibly 'null'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(51,14): error TS2344: Type 'number' does not satisfy the constraint 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(52,14): error TS2344: Type 'null' does not satisfy the constraint 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(53,14): error TS2344: Type 'undefined' does not satisfy the constraint 'object'. ==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts (18 errors) ==== - var a: object declare var b: object | null declare var c: object | undefined diff --git a/tests/baselines/reference/nonPrimitiveStrictNull.js b/tests/baselines/reference/nonPrimitiveStrictNull.js index 754ca8cac7d..6239affd9a0 100644 --- a/tests/baselines/reference/nonPrimitiveStrictNull.js +++ b/tests/baselines/reference/nonPrimitiveStrictNull.js @@ -1,5 +1,4 @@ //// [nonPrimitiveStrictNull.ts] - var a: object declare var b: object | null declare var c: object | undefined diff --git a/tests/baselines/reference/nounusedTypeParameterConstraint.js b/tests/baselines/reference/nounusedTypeParameterConstraint.js index f8881e6d0a0..a448315fa70 100644 --- a/tests/baselines/reference/nounusedTypeParameterConstraint.js +++ b/tests/baselines/reference/nounusedTypeParameterConstraint.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nounusedTypeParameterConstraint.ts] //// //// [bar.ts] - export interface IEventSourcedEntity { } //// [test.ts] diff --git a/tests/baselines/reference/nounusedTypeParameterConstraint.symbols b/tests/baselines/reference/nounusedTypeParameterConstraint.symbols index 40364460f50..559d678e8b3 100644 --- a/tests/baselines/reference/nounusedTypeParameterConstraint.symbols +++ b/tests/baselines/reference/nounusedTypeParameterConstraint.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/bar.ts === - export interface IEventSourcedEntity { } >IEventSourcedEntity : Symbol(IEventSourcedEntity, Decl(bar.ts, 0, 0)) diff --git a/tests/baselines/reference/nounusedTypeParameterConstraint.types b/tests/baselines/reference/nounusedTypeParameterConstraint.types index 0ded5540092..ac8d227a5f1 100644 --- a/tests/baselines/reference/nounusedTypeParameterConstraint.types +++ b/tests/baselines/reference/nounusedTypeParameterConstraint.types @@ -1,5 +1,4 @@ === tests/cases/compiler/bar.ts === - export interface IEventSourcedEntity { } >IEventSourcedEntity : IEventSourcedEntity diff --git a/tests/baselines/reference/null.errors.txt b/tests/baselines/reference/null.errors.txt index f957507438c..6b05bfb94d1 100644 --- a/tests/baselines/reference/null.errors.txt +++ b/tests/baselines/reference/null.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/null.ts(4,9): error TS2531: Object is possibly 'null'. +tests/cases/compiler/null.ts(3,9): error TS2531: Object is possibly 'null'. ==== tests/cases/compiler/null.ts (1 errors) ==== - var x=null; var y=3+x; var z=3+null; diff --git a/tests/baselines/reference/null.js b/tests/baselines/reference/null.js index a58c5f7ed16..2eb14e240bc 100644 --- a/tests/baselines/reference/null.js +++ b/tests/baselines/reference/null.js @@ -1,5 +1,4 @@ //// [null.ts] - var x=null; var y=3+x; var z=3+null; diff --git a/tests/baselines/reference/numericLiteralTypes2.js b/tests/baselines/reference/numericLiteralTypes2.js index ea82d00832c..ff0404e42dd 100644 --- a/tests/baselines/reference/numericLiteralTypes2.js +++ b/tests/baselines/reference/numericLiteralTypes2.js @@ -1,5 +1,4 @@ //// [numericLiteralTypes2.ts] - type A1 = 1; type A2 = 1.0; type A3 = 1e0; diff --git a/tests/baselines/reference/numericLiteralTypes2.symbols b/tests/baselines/reference/numericLiteralTypes2.symbols index f0dbbda502e..59c814513e4 100644 --- a/tests/baselines/reference/numericLiteralTypes2.symbols +++ b/tests/baselines/reference/numericLiteralTypes2.symbols @@ -1,237 +1,236 @@ === tests/cases/conformance/types/literal/numericLiteralTypes2.ts === - type A1 = 1; >A1 : Symbol(A1, Decl(numericLiteralTypes2.ts, 0, 0)) type A2 = 1.0; ->A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 1, 12)) +>A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 0, 12)) type A3 = 1e0; ->A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 2, 14)) +>A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 1, 14)) type A4 = 10e-1; ->A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 3, 14)) +>A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 2, 14)) type A5 = 1 | 1.0 | 1e0 | 10e-1; ->A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 4, 16)) +>A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 3, 16)) function f1() { ->f1 : Symbol(f1, Decl(numericLiteralTypes2.ts, 5, 32)) +>f1 : Symbol(f1, Decl(numericLiteralTypes2.ts, 4, 32)) var a: A1 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) >A1 : Symbol(A1, Decl(numericLiteralTypes2.ts, 0, 0)) var a: A2 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 1, 12)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 0, 12)) var a: A3 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 2, 14)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 1, 14)) var a: A4 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 3, 14)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 2, 14)) var a: A5 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 4, 16)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 3, 16)) } type B1 = -1 | 0 | 1; ->B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 13, 1)) +>B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 12, 1)) type B2 = 1 | 0 | -1; ->B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 15, 21)) +>B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 14, 21)) type B3 = 0 | -1 | 1; ->B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 16, 21)) +>B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 15, 21)) function f2() { ->f2 : Symbol(f2, Decl(numericLiteralTypes2.ts, 17, 21)) +>f2 : Symbol(f2, Decl(numericLiteralTypes2.ts, 16, 21)) var b: B1 = -1; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7), Decl(numericLiteralTypes2.ts, 22, 7)) ->B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 13, 1)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 19, 7), Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7)) +>B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 12, 1)) var b: B2 = 0; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7), Decl(numericLiteralTypes2.ts, 22, 7)) ->B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 15, 21)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 19, 7), Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7)) +>B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 14, 21)) var b: B3 = 1; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7), Decl(numericLiteralTypes2.ts, 22, 7)) ->B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 16, 21)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 19, 7), Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7)) +>B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 15, 21)) } function f3(a: 1, b: 0 | 1 | 2) { ->f3 : Symbol(f3, Decl(numericLiteralTypes2.ts, 23, 1)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>f3 : Symbol(f3, Decl(numericLiteralTypes2.ts, 22, 1)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a + b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a - b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a * b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a / b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a % b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a | b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a & b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a ^ b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = -b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = ~b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a == b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a != b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a === b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a !== b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a > b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a < b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a >= b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a <= b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = !b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) } function f4(a: 1, b: 0 | 1 | 2) { ->f4 : Symbol(f4, Decl(numericLiteralTypes2.ts, 45, 1)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 47, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 47, 17)) +>f4 : Symbol(f4, Decl(numericLiteralTypes2.ts, 44, 1)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 46, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 46, 17)) a++; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 47, 12)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 46, 12)) b++; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 47, 17)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 46, 17)) } declare function g(x: 0): string; ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 52, 19)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 51, 19)) declare function g(x: 1): boolean; ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 53, 19)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 52, 19)) declare function g(x: number): number; ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 54, 19)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 53, 19)) function f5(a: 1, b: 0 | 1 | 2) { ->f5 : Symbol(f5, Decl(numericLiteralTypes2.ts, 54, 38)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 56, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 56, 17)) +>f5 : Symbol(f5, Decl(numericLiteralTypes2.ts, 53, 38)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 55, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 55, 17)) var z1 = g(0); ->z1 : Symbol(z1, Decl(numericLiteralTypes2.ts, 57, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) +>z1 : Symbol(z1, Decl(numericLiteralTypes2.ts, 56, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) var z2 = g(1); ->z2 : Symbol(z2, Decl(numericLiteralTypes2.ts, 58, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) +>z2 : Symbol(z2, Decl(numericLiteralTypes2.ts, 57, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) var z3 = g(2); ->z3 : Symbol(z3, Decl(numericLiteralTypes2.ts, 59, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) +>z3 : Symbol(z3, Decl(numericLiteralTypes2.ts, 58, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) var z4 = g(a); ->z4 : Symbol(z4, Decl(numericLiteralTypes2.ts, 60, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 56, 12)) +>z4 : Symbol(z4, Decl(numericLiteralTypes2.ts, 59, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 55, 12)) var z5 = g(b); ->z5 : Symbol(z5, Decl(numericLiteralTypes2.ts, 61, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 56, 17)) +>z5 : Symbol(z5, Decl(numericLiteralTypes2.ts, 60, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 55, 17)) } function assertNever(x: never): never { ->assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 62, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 64, 21)) +>assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 61, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 63, 21)) throw new Error("Unexpected value"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } type Tag = 0 | 1 | 2; ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) function f10(x: Tag) { ->f10 : Symbol(f10, Decl(numericLiteralTypes2.ts, 68, 21)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 70, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f10 : Symbol(f10, Decl(numericLiteralTypes2.ts, 67, 21)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 69, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) switch (x) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 70, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 69, 13)) case 0: return "a"; case 1: return "b"; @@ -240,175 +239,175 @@ function f10(x: Tag) { } function f11(x: Tag) { ->f11 : Symbol(f11, Decl(numericLiteralTypes2.ts, 76, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 78, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f11 : Symbol(f11, Decl(numericLiteralTypes2.ts, 75, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 77, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) switch (x) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 77, 13)) case 0: return "a"; case 1: return "b"; case 2: return "c"; } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 62, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 78, 13)) +>assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 61, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 77, 13)) } function f12(x: Tag) { ->f12 : Symbol(f12, Decl(numericLiteralTypes2.ts, 85, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f12 : Symbol(f12, Decl(numericLiteralTypes2.ts, 84, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) if (x) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) } else { x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) } } function f13(x: Tag) { ->f13 : Symbol(f13, Decl(numericLiteralTypes2.ts, 94, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f13 : Symbol(f13, Decl(numericLiteralTypes2.ts, 93, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) if (x === 0 || x === 2) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) } else { x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) } } function f14(x: 0 | 1 | 2, y: string) { ->f14 : Symbol(f14, Decl(numericLiteralTypes2.ts, 103, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 105, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 105, 26)) +>f14 : Symbol(f14, Decl(numericLiteralTypes2.ts, 102, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 104, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 104, 26)) var a = x && y; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 106, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 105, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 105, 26)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 105, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 104, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 104, 26)) var b = x || y; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 107, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 105, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 105, 26)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 106, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 104, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 104, 26)) } function f15(x: 0 | false, y: 1 | "one") { ->f15 : Symbol(f15, Decl(numericLiteralTypes2.ts, 108, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>f15 : Symbol(f15, Decl(numericLiteralTypes2.ts, 107, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) var a = x && y; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 111, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 110, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) var b = y && x; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 112, 7)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 111, 7)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) var c = x || y; ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 113, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 112, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) var d = y || x; ->d : Symbol(d, Decl(numericLiteralTypes2.ts, 114, 7)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) +>d : Symbol(d, Decl(numericLiteralTypes2.ts, 113, 7)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) var e = !x; ->e : Symbol(e, Decl(numericLiteralTypes2.ts, 115, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) +>e : Symbol(e, Decl(numericLiteralTypes2.ts, 114, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) var f = !y; ->f : Symbol(f, Decl(numericLiteralTypes2.ts, 116, 7)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>f : Symbol(f, Decl(numericLiteralTypes2.ts, 115, 7)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) } type Item = ->Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 117, 1)) +>Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 116, 1)) { kind: 0, a: string } | ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) { kind: 1, b: string } | ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 121, 5)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) { kind: 2, c: string }; ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 122, 5)) ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 121, 5)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) function f20(x: Item) { ->f20 : Symbol(f20, Decl(numericLiteralTypes2.ts, 122, 27)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 117, 1)) +>f20 : Symbol(f20, Decl(numericLiteralTypes2.ts, 121, 27)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 116, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) +>x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) case 0: return x.a; ->x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) +>x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) case 1: return x.b; ->x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) +>x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) case 2: return x.c; ->x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) +>x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) } } function f21(x: Item) { ->f21 : Symbol(f21, Decl(numericLiteralTypes2.ts, 130, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 117, 1)) +>f21 : Symbol(f21, Decl(numericLiteralTypes2.ts, 129, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 116, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) +>x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) case 0: return x.a; ->x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) +>x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) case 1: return x.b; ->x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) +>x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) case 2: return x.c; ->x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) +>x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 62, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) +>assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 61, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) } diff --git a/tests/baselines/reference/numericLiteralTypes2.types b/tests/baselines/reference/numericLiteralTypes2.types index 4c67154ad41..c5bcff48f7f 100644 --- a/tests/baselines/reference/numericLiteralTypes2.types +++ b/tests/baselines/reference/numericLiteralTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/numericLiteralTypes2.ts === - type A1 = 1; >A1 : 1 diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt index b5dc0ac3c4b..db74b4b199f 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers01.ts(2,13): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers01.ts(1,13): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers01.ts (1 errors) ==== - var { while } = { while: 1 } ~ !!! error TS1005: ':' expected. \ No newline at end of file diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js index a905e53f221..ec0cae158fc 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers01.ts] - var { while } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers01.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt index 7ac72469d08..5809148707b 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(2,20): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(1,14): error TS1003: Identifier expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(1,20): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts (2 errors) ==== - var { while: while } = { while: 1 } ~~~~~ !!! error TS1003: Identifier expected. diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js index 5bc6e1f9963..88f5e1b56d8 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers02.ts] - var { while: while } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers02.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt index 6ffad2c0345..ad6a9299112 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers03.ts(2,15): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers03.ts(1,15): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers03.ts (1 errors) ==== - var { "while" } = { while: 1 } ~ !!! error TS1005: ':' expected. \ No newline at end of file diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js index 3d8643d63ce..6c9a539bb69 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers03.ts] - var { "while" } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers03.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt index 69a8b48b2f1..5481b5efe55 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(2,16): error TS1003: Identifier expected. -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(2,22): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(1,16): error TS1003: Identifier expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(1,22): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts (2 errors) ==== - var { "while": while } = { while: 1 } ~~~~~ !!! error TS1003: Identifier expected. diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js index de7608a77d2..a93e76c7e9c 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers04.ts] - var { "while": while } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers04.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js index 41c46c46506..08f8e632f29 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers05.ts] - var { as } = { as: 1 } //// [objectBindingPatternKeywordIdentifiers05.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols index 5ac9bb815f8..dc39116a2c2 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers05.ts === - var { as } = { as: 1 } ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 5)) ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 14)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 0, 5)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 0, 14)) diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types index d5838d7174a..93cf447a7f1 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers05.ts === - var { as } = { as: 1 } >as : number >{ as: 1 } : { as: number; } diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js index d24c468e891..9f29dfff1f8 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers06.ts] - var { as: as } = { as: 1 } //// [objectBindingPatternKeywordIdentifiers06.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols index f0546012498..757cc6c3709 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers06.ts === - var { as: as } = { as: 1 } ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 18)) ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 5)) ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 18)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 0, 18)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 0, 5)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 0, 18)) diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types index 427957c1ef8..73416da85c9 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers06.ts === - var { as: as } = { as: 1 } >as : any >as : number diff --git a/tests/baselines/reference/objectCreate-errors.errors.txt b/tests/baselines/reference/objectCreate-errors.errors.txt index 38b9158351e..12f62cc4d2c 100644 --- a/tests/baselines/reference/objectCreate-errors.errors.txt +++ b/tests/baselines/reference/objectCreate-errors.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/objectCreate-errors.ts(2,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(3,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(4,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(5,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(8,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(9,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(10,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(11,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(1,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(2,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(3,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(4,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(7,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(8,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(9,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(10,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. ==== tests/cases/compiler/objectCreate-errors.ts (8 errors) ==== - var e1 = Object.create(1); // Error ~ !!! error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. diff --git a/tests/baselines/reference/objectCreate-errors.js b/tests/baselines/reference/objectCreate-errors.js index 959b2f9473d..7f358a1d00f 100644 --- a/tests/baselines/reference/objectCreate-errors.js +++ b/tests/baselines/reference/objectCreate-errors.js @@ -1,5 +1,4 @@ //// [objectCreate-errors.ts] - var e1 = Object.create(1); // Error var e2 = Object.create("string"); // Error var e3 = Object.create(false); // Error diff --git a/tests/baselines/reference/objectCreate.js b/tests/baselines/reference/objectCreate.js index 728fa8ca21a..96e5a3ac9bc 100644 --- a/tests/baselines/reference/objectCreate.js +++ b/tests/baselines/reference/objectCreate.js @@ -1,5 +1,4 @@ //// [objectCreate.ts] - declare var union: null | { a: number, b: string }; var n = Object.create(null); // object diff --git a/tests/baselines/reference/objectCreate.symbols b/tests/baselines/reference/objectCreate.symbols index 7ae0a796cc8..00fe86a2d10 100644 --- a/tests/baselines/reference/objectCreate.symbols +++ b/tests/baselines/reference/objectCreate.symbols @@ -1,72 +1,71 @@ === tests/cases/compiler/objectCreate.ts === - declare var union: null | { a: number, b: string }; ->union : Symbol(union, Decl(objectCreate.ts, 1, 11)) ->a : Symbol(a, Decl(objectCreate.ts, 1, 27)) ->b : Symbol(b, Decl(objectCreate.ts, 1, 38)) +>union : Symbol(union, Decl(objectCreate.ts, 0, 11)) +>a : Symbol(a, Decl(objectCreate.ts, 0, 27)) +>b : Symbol(b, Decl(objectCreate.ts, 0, 38)) var n = Object.create(null); // object ->n : Symbol(n, Decl(objectCreate.ts, 3, 3)) +>n : Symbol(n, Decl(objectCreate.ts, 2, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } ->t : Symbol(t, Decl(objectCreate.ts, 4, 3)) +>t : Symbol(t, Decl(objectCreate.ts, 3, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate.ts, 4, 23)) ->b : Symbol(b, Decl(objectCreate.ts, 4, 29)) +>a : Symbol(a, Decl(objectCreate.ts, 3, 23)) +>b : Symbol(b, Decl(objectCreate.ts, 3, 29)) var u = Object.create(union); // object | {a: number, b: string } ->u : Symbol(u, Decl(objectCreate.ts, 5, 3)) +>u : Symbol(u, Decl(objectCreate.ts, 4, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate.ts, 0, 11)) var e = Object.create({}); // {} ->e : Symbol(e, Decl(objectCreate.ts, 6, 3)) +>e : Symbol(e, Decl(objectCreate.ts, 5, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var o = Object.create({}); // object ->o : Symbol(o, Decl(objectCreate.ts, 7, 3)) +>o : Symbol(o, Decl(objectCreate.ts, 6, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create(null, {}); // any ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({ a: 1, b: "" }, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate.ts, 10, 23)) ->b : Symbol(b, Decl(objectCreate.ts, 10, 29)) +>a : Symbol(a, Decl(objectCreate.ts, 9, 23)) +>b : Symbol(b, Decl(objectCreate.ts, 9, 29)) var a = Object.create(union, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate.ts, 0, 11)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectCreate.types b/tests/baselines/reference/objectCreate.types index b4e0e72061e..5181a769a9c 100644 --- a/tests/baselines/reference/objectCreate.types +++ b/tests/baselines/reference/objectCreate.types @@ -1,5 +1,4 @@ === tests/cases/compiler/objectCreate.ts === - declare var union: null | { a: number, b: string }; >union : { a: number; b: string; } | null >null : null diff --git a/tests/baselines/reference/objectCreate2.js b/tests/baselines/reference/objectCreate2.js index cfc79c2ef35..8328f523a6d 100644 --- a/tests/baselines/reference/objectCreate2.js +++ b/tests/baselines/reference/objectCreate2.js @@ -1,5 +1,4 @@ //// [objectCreate2.ts] - declare var union: null | { a: number, b: string }; var n = Object.create(null); // any diff --git a/tests/baselines/reference/objectCreate2.symbols b/tests/baselines/reference/objectCreate2.symbols index bf57b6d5e07..3579aba0817 100644 --- a/tests/baselines/reference/objectCreate2.symbols +++ b/tests/baselines/reference/objectCreate2.symbols @@ -1,72 +1,71 @@ === tests/cases/compiler/objectCreate2.ts === - declare var union: null | { a: number, b: string }; ->union : Symbol(union, Decl(objectCreate2.ts, 1, 11)) ->a : Symbol(a, Decl(objectCreate2.ts, 1, 27)) ->b : Symbol(b, Decl(objectCreate2.ts, 1, 38)) +>union : Symbol(union, Decl(objectCreate2.ts, 0, 11)) +>a : Symbol(a, Decl(objectCreate2.ts, 0, 27)) +>b : Symbol(b, Decl(objectCreate2.ts, 0, 38)) var n = Object.create(null); // any ->n : Symbol(n, Decl(objectCreate2.ts, 3, 3)) +>n : Symbol(n, Decl(objectCreate2.ts, 2, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } ->t : Symbol(t, Decl(objectCreate2.ts, 4, 3)) +>t : Symbol(t, Decl(objectCreate2.ts, 3, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate2.ts, 4, 23)) ->b : Symbol(b, Decl(objectCreate2.ts, 4, 29)) +>a : Symbol(a, Decl(objectCreate2.ts, 3, 23)) +>b : Symbol(b, Decl(objectCreate2.ts, 3, 29)) var u = Object.create(union); // {a: number, b: string } ->u : Symbol(u, Decl(objectCreate2.ts, 5, 3)) +>u : Symbol(u, Decl(objectCreate2.ts, 4, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate2.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate2.ts, 0, 11)) var e = Object.create({}); // {} ->e : Symbol(e, Decl(objectCreate2.ts, 6, 3)) +>e : Symbol(e, Decl(objectCreate2.ts, 5, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var o = Object.create({}); // object ->o : Symbol(o, Decl(objectCreate2.ts, 7, 3)) +>o : Symbol(o, Decl(objectCreate2.ts, 6, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create(null, {}); // any ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({ a: 1, b: "" }, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate2.ts, 10, 23)) ->b : Symbol(b, Decl(objectCreate2.ts, 10, 29)) +>a : Symbol(a, Decl(objectCreate2.ts, 9, 23)) +>b : Symbol(b, Decl(objectCreate2.ts, 9, 29)) var a = Object.create(union, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate2.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate2.ts, 0, 11)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectCreate2.types b/tests/baselines/reference/objectCreate2.types index 3e19c08bfc0..cbda9ef774e 100644 --- a/tests/baselines/reference/objectCreate2.types +++ b/tests/baselines/reference/objectCreate2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/objectCreate2.ts === - declare var union: null | { a: number, b: string }; >union : { a: number; b: string; } >null : null diff --git a/tests/baselines/reference/objectLiteralErrors.errors.txt b/tests/baselines/reference/objectLiteralErrors.errors.txt index 0e0db0b414f..2a2dc7dd575 100644 --- a/tests/baselines/reference/objectLiteralErrors.errors.txt +++ b/tests/baselines/reference/objectLiteralErrors.errors.txt @@ -1,85 +1,84 @@ -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(3,18): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(4,19): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(5,18): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(6,21): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(7,19): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(8,18): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(9,20): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(10,20): error TS2300: Duplicate identifier '"a"'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(11,20): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(12,21): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(13,21): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(2,18): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(3,19): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(4,18): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(5,21): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(6,19): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(7,18): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(8,20): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(9,20): error TS2300: Duplicate identifier '"a"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(10,20): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(11,21): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(12,21): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(13,19): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(14,19): error TS2300: Duplicate identifier '0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(15,19): error TS2300: Duplicate identifier '0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(16,19): error TS2300: Duplicate identifier '0x0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(17,19): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(17,19): error TS2300: Duplicate identifier '000'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(18,23): error TS2300: Duplicate identifier '1e2'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(19,22): error TS2300: Duplicate identifier '3.2e1'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(20,25): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(15,19): error TS2300: Duplicate identifier '0x0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(16,19): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(16,19): error TS2300: Duplicate identifier '000'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(17,23): error TS2300: Duplicate identifier '1e2'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(18,22): error TS2300: Duplicate identifier '3.2e1'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(19,25): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(22,12): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(22,22): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(22,22): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,22): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,22): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,23): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,23): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,23): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,22): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,22): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,22): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,22): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,25): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,25): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,25): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,25): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,23): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,23): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,23): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,22): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,22): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,22): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,22): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,12): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,24): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,24): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,12): error TS2300: Duplicate identifier ''a''. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,24): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,24): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,24): error TS2300: Duplicate identifier '"a"'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,12): error TS2300: Duplicate identifier ''a''. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,24): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,24): error TS2300: Duplicate identifier '"a"'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,12): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,24): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,24): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,13): error TS2300: Duplicate identifier '"a"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,24): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,13): error TS2300: Duplicate identifier '"a"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,25): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,25): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,13): error TS2300: Duplicate identifier '1.0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,25): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,25): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,13): error TS2300: Duplicate identifier '1.0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,25): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,25): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,25): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,13): error TS2300: Duplicate identifier '0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,23): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,23): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(34,13): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(34,23): error TS1119: An object literal cannot have property and accessor with the same name. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(34,23): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,13): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,23): error TS2300: Duplicate identifier '0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,23): error TS2300: Duplicate identifier '0x0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,13): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,23): error TS2300: Duplicate identifier '0x0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,13): error TS2300: Duplicate identifier '0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,23): error TS2300: Duplicate identifier '000'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,13): error TS2300: Duplicate identifier '"100"'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,27): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,27): error TS2300: Duplicate identifier '1e2'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,13): error TS2300: Duplicate identifier '0x20'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,26): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,26): error TS2300: Duplicate identifier '3.2e1'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(40,13): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(40,46): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(40,46): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(43,16): error TS2380: 'get' and 'set' accessor must have the same type. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(43,47): error TS2380: 'get' and 'set' accessor must have the same type. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(44,22): error TS2322: Type '4' is not assignable to type 'string'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(45,16): error TS2380: 'get' and 'set' accessor must have the same type. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(45,55): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,23): error TS2300: Duplicate identifier '000'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,13): error TS2300: Duplicate identifier '"100"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,27): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,27): error TS2300: Duplicate identifier '1e2'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,13): error TS2300: Duplicate identifier '0x20'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,26): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,26): error TS2300: Duplicate identifier '3.2e1'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,13): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,46): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,46): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(42,16): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(42,47): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(43,22): error TS2322: Type '4' is not assignable to type 'string'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(44,16): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(44,55): error TS2380: 'get' and 'set' accessor must have the same type. ==== tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts (78 errors) ==== - // Multiple properties with the same name var e1 = { a: 0, a: 0 }; ~ diff --git a/tests/baselines/reference/objectLiteralErrors.js b/tests/baselines/reference/objectLiteralErrors.js index 4dccc78b67d..1f721d3e71c 100644 --- a/tests/baselines/reference/objectLiteralErrors.js +++ b/tests/baselines/reference/objectLiteralErrors.js @@ -1,5 +1,4 @@ //// [objectLiteralErrors.ts] - // Multiple properties with the same name var e1 = { a: 0, a: 0 }; var e2 = { a: '', a: '' }; diff --git a/tests/baselines/reference/objectLiteralErrorsES3.errors.txt b/tests/baselines/reference/objectLiteralErrorsES3.errors.txt index 2788c23a278..99b4f5c4ae0 100644 --- a/tests/baselines/reference/objectLiteralErrorsES3.errors.txt +++ b/tests/baselines/reference/objectLiteralErrorsES3.errors.txt @@ -1,11 +1,10 @@ +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(1,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(4,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(4,40): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(3,40): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts (4 errors) ==== - var e1 = { get a() { return 4; } }; ~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. diff --git a/tests/baselines/reference/objectLiteralErrorsES3.js b/tests/baselines/reference/objectLiteralErrorsES3.js index 031a68fd109..e45004c69b3 100644 --- a/tests/baselines/reference/objectLiteralErrorsES3.js +++ b/tests/baselines/reference/objectLiteralErrorsES3.js @@ -1,5 +1,4 @@ //// [objectLiteralErrorsES3.ts] - var e1 = { get a() { return 4; } }; var e2 = { set a(n) { } }; var e3 = { get a() { return ''; }, set a(n) { } }; diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js index c9d7edf8140..de51ca232d1 100644 --- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js +++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js @@ -1,5 +1,4 @@ //// [objectLiteralShorthandPropertiesWithModuleES6.ts] - module m { export var x; } diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols index bcb69cc9a97..c5b0756dcc2 100644 --- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols +++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols @@ -1,28 +1,27 @@ === tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesWithModuleES6.ts === - module m { ->m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 3, 1)) +>m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 1)) export var x; ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 14)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 1, 14)) } module m { ->m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 3, 1)) +>m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 1)) var z = x; ->z : Symbol(z, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 6, 7)) ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 14)) +>z : Symbol(z, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 5, 7)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 1, 14)) var y = { ->y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 7)) +>y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 6, 7)) a: x, ->a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 13)) ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 14)) +>a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 6, 13)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 1, 14)) x ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 8, 13)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 13)) }; } diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types index 1030010d6c6..5a44fc2b8c4 100644 --- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types +++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesWithModuleES6.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/objectSpreadStrictNull.js b/tests/baselines/reference/objectSpreadStrictNull.js index 84604d728cd..8a4cf0e5f9f 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.js +++ b/tests/baselines/reference/objectSpreadStrictNull.js @@ -1,5 +1,4 @@ //// [objectSpreadStrictNull.ts] - function f( definiteBoolean: { sn: boolean }, definiteString: { sn: string }, diff --git a/tests/baselines/reference/objectSpreadStrictNull.symbols b/tests/baselines/reference/objectSpreadStrictNull.symbols index 2586d4ddbd3..e9202767945 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.symbols +++ b/tests/baselines/reference/objectSpreadStrictNull.symbols @@ -1,81 +1,80 @@ === tests/cases/conformance/types/spread/objectSpreadStrictNull.ts === - function f( >f : Symbol(f, Decl(objectSpreadStrictNull.ts, 0, 0)) definiteBoolean: { sn: boolean }, ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 2, 22)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 1, 22)) definiteString: { sn: string }, ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 3, 21)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 2, 21)) optionalString: { sn?: string }, ->optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 3, 35)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 4, 21)) +>optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 2, 35)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 3, 21)) optionalNumber: { sn?: number }, ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 5, 21)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 4, 21)) undefinedString: { sn: string | undefined }, ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 6, 22)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 5, 22)) undefinedNumber: { sn: number | undefined }) { ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 7, 22)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 6, 22)) // optional let optionalUnionStops: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...optionalNumber }; ->optionalUnionStops : Symbol(optionalUnionStops, Decl(objectSpreadStrictNull.ts, 9, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 9, 29)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>optionalUnionStops : Symbol(optionalUnionStops, Decl(objectSpreadStrictNull.ts, 8, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 8, 29)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) let optionalUnionDuplicates: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...optionalString, ...optionalNumber }; ->optionalUnionDuplicates : Symbol(optionalUnionDuplicates, Decl(objectSpreadStrictNull.ts, 10, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 10, 34)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 3, 35)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>optionalUnionDuplicates : Symbol(optionalUnionDuplicates, Decl(objectSpreadStrictNull.ts, 9, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 9, 34)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 2, 35)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) let allOptional: { sn?: string | number } = { ...optionalString, ...optionalNumber }; ->allOptional : Symbol(allOptional, Decl(objectSpreadStrictNull.ts, 11, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 11, 22)) ->optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 3, 35)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>allOptional : Symbol(allOptional, Decl(objectSpreadStrictNull.ts, 10, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 10, 22)) +>optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 2, 35)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) // undefined let undefinedUnionStops: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...undefinedNumber }; ->undefinedUnionStops : Symbol(undefinedUnionStops, Decl(objectSpreadStrictNull.ts, 14, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 14, 30)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) +>undefinedUnionStops : Symbol(undefinedUnionStops, Decl(objectSpreadStrictNull.ts, 13, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 13, 30)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) let undefinedUnionDuplicates: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...undefinedString, ...undefinedNumber }; ->undefinedUnionDuplicates : Symbol(undefinedUnionDuplicates, Decl(objectSpreadStrictNull.ts, 15, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 15, 35)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) +>undefinedUnionDuplicates : Symbol(undefinedUnionDuplicates, Decl(objectSpreadStrictNull.ts, 14, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 14, 35)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) let allUndefined: { sn: string | number | undefined } = { ...undefinedString, ...undefinedNumber }; ->allUndefined : Symbol(allUndefined, Decl(objectSpreadStrictNull.ts, 16, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 16, 23)) ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) +>allUndefined : Symbol(allUndefined, Decl(objectSpreadStrictNull.ts, 15, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 15, 23)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) let undefinedWithOptionalContinues: { sn: string | number | boolean } = { ...definiteBoolean, ...undefinedString, ...optionalNumber }; ->undefinedWithOptionalContinues : Symbol(undefinedWithOptionalContinues, Decl(objectSpreadStrictNull.ts, 18, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 18, 41)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>undefinedWithOptionalContinues : Symbol(undefinedWithOptionalContinues, Decl(objectSpreadStrictNull.ts, 17, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 17, 41)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) } diff --git a/tests/baselines/reference/objectSpreadStrictNull.types b/tests/baselines/reference/objectSpreadStrictNull.types index c9ed742c6b6..f70f0a9cad2 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.types +++ b/tests/baselines/reference/objectSpreadStrictNull.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/spread/objectSpreadStrictNull.ts === - function f( >f : (definiteBoolean: { sn: boolean; }, definiteString: { sn: string; }, optionalString: { sn?: string | undefined; }, optionalNumber: { sn?: number | undefined; }, undefinedString: { sn: string | undefined; }, undefinedNumber: { sn: number | undefined; }) => void diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js index 3ff5817692b..ac227a091c7 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js @@ -1,5 +1,4 @@ //// [objectTypeWithStringNamedNumericProperty.ts] - // string named numeric properties are legal and distinct when indexed by string values // indexed numerically the value is converted to a number // no errors expected below diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols index 480886711d5..9b5202d5dd4 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/types/members/objectTypeWithStringNamedNumericProperty.ts === - // string named numeric properties are legal and distinct when indexed by string values // indexed numerically the value is converted to a number // no errors expected below @@ -25,93 +24,93 @@ class C { } var c: C; ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) >C : Symbol(C, Decl(objectTypeWithStringNamedNumericProperty.ts, 0, 0)) var r1 = c['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'0.1' : Symbol(C["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 5, 9)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'0.1' : Symbol(C["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 4, 9)) var r2 = c['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'.1' : Symbol(C[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 16)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'.1' : Symbol(C[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 5, 16)) var r3 = c['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1' : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1' : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = c['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1.' : Symbol(C["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 8, 16)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1.' : Symbol(C["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 16)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = c['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1..' : Symbol(C["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 9, 17)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1..' : Symbol(C["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 8, 17)) var r6 = c['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1.0' : Symbol(C["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 10, 19)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1.0' : Symbol(C["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 9, 19)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) interface I { ->I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 16)) +>I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 16)) "0.1": void; ".1": Object; @@ -131,93 +130,93 @@ interface I { } var i: I; ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 16)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 16)) var r1 = i['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'0.1' : Symbol(I["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 36, 13)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'0.1' : Symbol(I["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 35, 13)) var r2 = i['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'.1' : Symbol(I[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 16)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'.1' : Symbol(I[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 36, 16)) var r3 = i['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1' : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1' : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = i['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1.' : Symbol(I["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 39, 16)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1.' : Symbol(I["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 16)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = i['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1..' : Symbol(I["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 40, 17)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1..' : Symbol(I["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 39, 17)) var r6 = i['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1.0' : Symbol(I["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 19)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1.0' : Symbol(I["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 40, 19)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var a: { ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) "0.1": void; ".1": Object; @@ -237,89 +236,89 @@ var a: { } var r1 = a['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 8)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 8)) var r2 = a['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 68, 16)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 16)) var r3 = a['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 69, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 68, 17)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = a['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 70, 16)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 69, 16)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = a['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 71, 17)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 70, 17)) var r6 = a['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 72, 19)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 71, 19)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var b = { ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) "0.1": null, ".1": new Object(), @@ -338,84 +337,84 @@ var b = { }; var r1 = b['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 9)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 9)) var r2 = b['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 98, 22)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 22)) var r3 = b['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 99, 23)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 98, 23)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = b['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 100, 11)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 99, 11)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = b['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 101, 13)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 100, 13)) var r6 = b['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 102, 16)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 101, 16)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types index 1f34c4fafac..98081e6ab6c 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/members/objectTypeWithStringNamedNumericProperty.ts === - // string named numeric properties are legal and distinct when indexed by string values // indexed numerically the value is converted to a number // no errors expected below diff --git a/tests/baselines/reference/optionalBindingParameters1.errors.txt b/tests/baselines/reference/optionalBindingParameters1.errors.txt index 66256edf727..339f0042983 100644 --- a/tests/baselines/reference/optionalBindingParameters1.errors.txt +++ b/tests/baselines/reference/optionalBindingParameters1.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. -tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. +tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(1,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. +tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(7,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts (2 errors) ==== - function foo([x,y,z]?: [string, number, boolean]) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature. diff --git a/tests/baselines/reference/optionalBindingParameters1.js b/tests/baselines/reference/optionalBindingParameters1.js index 536cb1e567a..9c6a5b3fdda 100644 --- a/tests/baselines/reference/optionalBindingParameters1.js +++ b/tests/baselines/reference/optionalBindingParameters1.js @@ -1,5 +1,4 @@ //// [optionalBindingParameters1.ts] - function foo([x,y,z]?: [string, number, boolean]) { } diff --git a/tests/baselines/reference/optionalBindingParameters2.errors.txt b/tests/baselines/reference/optionalBindingParameters2.errors.txt index 34f36d32380..b7e9bb1c2da 100644 --- a/tests/baselines/reference/optionalBindingParameters2.errors.txt +++ b/tests/baselines/reference/optionalBindingParameters2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. -tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(8,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. +tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(1,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. +tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(7,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. Types of property 'x' are incompatible. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts (2 errors) ==== - function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature. diff --git a/tests/baselines/reference/optionalBindingParameters2.js b/tests/baselines/reference/optionalBindingParameters2.js index 04e1138561a..ed1a5961fe2 100644 --- a/tests/baselines/reference/optionalBindingParameters2.js +++ b/tests/baselines/reference/optionalBindingParameters2.js @@ -1,5 +1,4 @@ //// [optionalBindingParameters2.ts] - function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { } diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt index 771ada1a464..d2be862f6ef 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt +++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(9,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. +tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(8,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts (1 errors) ==== - function foo([x, y, z] ?: [string, number, boolean]); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.js b/tests/baselines/reference/optionalBindingParametersInOverloads1.js index 9fd64d0da9e..05ad934c260 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads1.js +++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.js @@ -1,5 +1,4 @@ //// [optionalBindingParametersInOverloads1.ts] - function foo([x, y, z] ?: [string, number, boolean]); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt index e2546aff724..ccbdfce2fdd 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt +++ b/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts(9,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. +tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts(8,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. Types of property 'x' are incompatible. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts (1 errors) ==== - function foo({ x, y, z }?: { x: string; y: number; z: boolean }); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads2.js b/tests/baselines/reference/optionalBindingParametersInOverloads2.js index 033d81993f5..956441b89e8 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads2.js +++ b/tests/baselines/reference/optionalBindingParametersInOverloads2.js @@ -1,5 +1,4 @@ //// [optionalBindingParametersInOverloads2.ts] - function foo({ x, y, z }?: { x: string; y: number; z: boolean }); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalMethods.js b/tests/baselines/reference/optionalMethods.js index a3685175f66..d219466c562 100644 --- a/tests/baselines/reference/optionalMethods.js +++ b/tests/baselines/reference/optionalMethods.js @@ -1,5 +1,4 @@ //// [optionalMethods.ts] - interface Foo { a: number; b?: number; diff --git a/tests/baselines/reference/optionalMethods.symbols b/tests/baselines/reference/optionalMethods.symbols index 55c5ec958da..9e9d3a0a332 100644 --- a/tests/baselines/reference/optionalMethods.symbols +++ b/tests/baselines/reference/optionalMethods.symbols @@ -1,203 +1,202 @@ === tests/cases/conformance/types/namedTypes/optionalMethods.ts === - interface Foo { >Foo : Symbol(Foo, Decl(optionalMethods.ts, 0, 0)) a: number; ->a : Symbol(Foo.a, Decl(optionalMethods.ts, 1, 15)) +>a : Symbol(Foo.a, Decl(optionalMethods.ts, 0, 15)) b?: number; ->b : Symbol(Foo.b, Decl(optionalMethods.ts, 2, 14)) +>b : Symbol(Foo.b, Decl(optionalMethods.ts, 1, 14)) f(): number; ->f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) +>f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) g?(): number; ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) } function test1(x: Foo) { ->test1 : Symbol(test1, Decl(optionalMethods.ts, 6, 1)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) +>test1 : Symbol(test1, Decl(optionalMethods.ts, 5, 1)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) >Foo : Symbol(Foo, Decl(optionalMethods.ts, 0, 0)) x.a; ->x.a : Symbol(Foo.a, Decl(optionalMethods.ts, 1, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->a : Symbol(Foo.a, Decl(optionalMethods.ts, 1, 15)) +>x.a : Symbol(Foo.a, Decl(optionalMethods.ts, 0, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>a : Symbol(Foo.a, Decl(optionalMethods.ts, 0, 15)) x.b; ->x.b : Symbol(Foo.b, Decl(optionalMethods.ts, 2, 14)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->b : Symbol(Foo.b, Decl(optionalMethods.ts, 2, 14)) +>x.b : Symbol(Foo.b, Decl(optionalMethods.ts, 1, 14)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>b : Symbol(Foo.b, Decl(optionalMethods.ts, 1, 14)) x.f; ->x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) +>x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) x.g; ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) let f1 = x.f(); ->f1 : Symbol(f1, Decl(optionalMethods.ts, 13, 7)) ->x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) +>f1 : Symbol(f1, Decl(optionalMethods.ts, 12, 7)) +>x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) let g1 = x.g && x.g(); ->g1 : Symbol(g1, Decl(optionalMethods.ts, 14, 7)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>g1 : Symbol(g1, Decl(optionalMethods.ts, 13, 7)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) let g2 = x.g ? x.g() : 0; ->g2 : Symbol(g2, Decl(optionalMethods.ts, 15, 7)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>g2 : Symbol(g2, Decl(optionalMethods.ts, 14, 7)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) } class Bar { ->Bar : Symbol(Bar, Decl(optionalMethods.ts, 16, 1)) +>Bar : Symbol(Bar, Decl(optionalMethods.ts, 15, 1)) a: number; ->a : Symbol(Bar.a, Decl(optionalMethods.ts, 18, 11)) +>a : Symbol(Bar.a, Decl(optionalMethods.ts, 17, 11)) b?: number; ->b : Symbol(Bar.b, Decl(optionalMethods.ts, 19, 14)) +>b : Symbol(Bar.b, Decl(optionalMethods.ts, 18, 14)) c? = 2; ->c : Symbol(Bar.c, Decl(optionalMethods.ts, 20, 15)) +>c : Symbol(Bar.c, Decl(optionalMethods.ts, 19, 15)) constructor(public d?: number, public e = 10) {} ->d : Symbol(Bar.d, Decl(optionalMethods.ts, 22, 16)) ->e : Symbol(Bar.e, Decl(optionalMethods.ts, 22, 34)) +>d : Symbol(Bar.d, Decl(optionalMethods.ts, 21, 16)) +>e : Symbol(Bar.e, Decl(optionalMethods.ts, 21, 34)) f() { ->f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) +>f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) return 1; } g?(): number; // Body of optional method can be omitted ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) h?() { ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) return 2; } } function test2(x: Bar) { ->test2 : Symbol(test2, Decl(optionalMethods.ts, 30, 1)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->Bar : Symbol(Bar, Decl(optionalMethods.ts, 16, 1)) +>test2 : Symbol(test2, Decl(optionalMethods.ts, 29, 1)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>Bar : Symbol(Bar, Decl(optionalMethods.ts, 15, 1)) x.a; ->x.a : Symbol(Bar.a, Decl(optionalMethods.ts, 18, 11)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->a : Symbol(Bar.a, Decl(optionalMethods.ts, 18, 11)) +>x.a : Symbol(Bar.a, Decl(optionalMethods.ts, 17, 11)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>a : Symbol(Bar.a, Decl(optionalMethods.ts, 17, 11)) x.b; ->x.b : Symbol(Bar.b, Decl(optionalMethods.ts, 19, 14)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->b : Symbol(Bar.b, Decl(optionalMethods.ts, 19, 14)) +>x.b : Symbol(Bar.b, Decl(optionalMethods.ts, 18, 14)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>b : Symbol(Bar.b, Decl(optionalMethods.ts, 18, 14)) x.c; ->x.c : Symbol(Bar.c, Decl(optionalMethods.ts, 20, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->c : Symbol(Bar.c, Decl(optionalMethods.ts, 20, 15)) +>x.c : Symbol(Bar.c, Decl(optionalMethods.ts, 19, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>c : Symbol(Bar.c, Decl(optionalMethods.ts, 19, 15)) x.d; ->x.d : Symbol(Bar.d, Decl(optionalMethods.ts, 22, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->d : Symbol(Bar.d, Decl(optionalMethods.ts, 22, 16)) +>x.d : Symbol(Bar.d, Decl(optionalMethods.ts, 21, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>d : Symbol(Bar.d, Decl(optionalMethods.ts, 21, 16)) x.e; ->x.e : Symbol(Bar.e, Decl(optionalMethods.ts, 22, 34)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->e : Symbol(Bar.e, Decl(optionalMethods.ts, 22, 34)) +>x.e : Symbol(Bar.e, Decl(optionalMethods.ts, 21, 34)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>e : Symbol(Bar.e, Decl(optionalMethods.ts, 21, 34)) x.f; ->x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) +>x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) x.g; ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) let f1 = x.f(); ->f1 : Symbol(f1, Decl(optionalMethods.ts, 40, 7)) ->x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) +>f1 : Symbol(f1, Decl(optionalMethods.ts, 39, 7)) +>x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) let g1 = x.g && x.g(); ->g1 : Symbol(g1, Decl(optionalMethods.ts, 41, 7)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>g1 : Symbol(g1, Decl(optionalMethods.ts, 40, 7)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) let g2 = x.g ? x.g() : 0; ->g2 : Symbol(g2, Decl(optionalMethods.ts, 42, 7)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>g2 : Symbol(g2, Decl(optionalMethods.ts, 41, 7)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) let h1 = x.h && x.h(); ->h1 : Symbol(h1, Decl(optionalMethods.ts, 43, 7)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) +>h1 : Symbol(h1, Decl(optionalMethods.ts, 42, 7)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) let h2 = x.h ? x.h() : 0; ->h2 : Symbol(h2, Decl(optionalMethods.ts, 44, 7)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) +>h2 : Symbol(h2, Decl(optionalMethods.ts, 43, 7)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) } class Base { ->Base : Symbol(Base, Decl(optionalMethods.ts, 45, 1)) +>Base : Symbol(Base, Decl(optionalMethods.ts, 44, 1)) a?: number; ->a : Symbol(Base.a, Decl(optionalMethods.ts, 47, 12)) +>a : Symbol(Base.a, Decl(optionalMethods.ts, 46, 12)) f?(): number; ->f : Symbol(Base.f, Decl(optionalMethods.ts, 48, 15)) +>f : Symbol(Base.f, Decl(optionalMethods.ts, 47, 15)) } class Derived extends Base { ->Derived : Symbol(Derived, Decl(optionalMethods.ts, 50, 1)) ->Base : Symbol(Base, Decl(optionalMethods.ts, 45, 1)) +>Derived : Symbol(Derived, Decl(optionalMethods.ts, 49, 1)) +>Base : Symbol(Base, Decl(optionalMethods.ts, 44, 1)) a = 1; ->a : Symbol(Derived.a, Decl(optionalMethods.ts, 52, 28)) +>a : Symbol(Derived.a, Decl(optionalMethods.ts, 51, 28)) f(): number { return 1; } ->f : Symbol(Derived.f, Decl(optionalMethods.ts, 53, 10)) +>f : Symbol(Derived.f, Decl(optionalMethods.ts, 52, 10)) } diff --git a/tests/baselines/reference/optionalMethods.types b/tests/baselines/reference/optionalMethods.types index cf545eda509..735ce95fee4 100644 --- a/tests/baselines/reference/optionalMethods.types +++ b/tests/baselines/reference/optionalMethods.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/namedTypes/optionalMethods.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/optionalParameterProperty.errors.txt b/tests/baselines/reference/optionalParameterProperty.errors.txt index d585ff6964d..c82dbd4ec9c 100644 --- a/tests/baselines/reference/optionalParameterProperty.errors.txt +++ b/tests/baselines/reference/optionalParameterProperty.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/optionalParameterProperty.ts(6,7): error TS2415: Class 'D' incorrectly extends base class 'C'. +tests/cases/compiler/optionalParameterProperty.ts(5,7): error TS2415: Class 'D' incorrectly extends base class 'C'. Types of property 'p' are incompatible. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. ==== tests/cases/compiler/optionalParameterProperty.ts (1 errors) ==== - class C { p: number; } diff --git a/tests/baselines/reference/optionalParameterProperty.js b/tests/baselines/reference/optionalParameterProperty.js index fc288d09767..da0d2286714 100644 --- a/tests/baselines/reference/optionalParameterProperty.js +++ b/tests/baselines/reference/optionalParameterProperty.js @@ -1,5 +1,4 @@ //// [optionalParameterProperty.ts] - class C { p: number; } diff --git a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt index 0d309327531..982318d2f25 100644 --- a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt +++ b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/optionalParamterAndVariableDeclaration2.ts(4,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'options' must be of type 'number | undefined', but here has type 'number'. +tests/cases/compiler/optionalParamterAndVariableDeclaration2.ts(3,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'options' must be of type 'number | undefined', but here has type 'number'. ==== tests/cases/compiler/optionalParamterAndVariableDeclaration2.ts (1 errors) ==== - class C { constructor(options?: number) { var options = (options || 0); diff --git a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js index a4ffc9f382d..0de4ac00a66 100644 --- a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js +++ b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js @@ -1,5 +1,4 @@ //// [optionalParamterAndVariableDeclaration2.ts] - class C { constructor(options?: number) { var options = (options || 0); diff --git a/tests/baselines/reference/optionalProperties01.js b/tests/baselines/reference/optionalProperties01.js index a614b9e7e37..75ad84fb24e 100644 --- a/tests/baselines/reference/optionalProperties01.js +++ b/tests/baselines/reference/optionalProperties01.js @@ -1,5 +1,4 @@ //// [optionalProperties01.ts] - interface Foo { required1: string; required2: string; diff --git a/tests/baselines/reference/optionalProperties01.symbols b/tests/baselines/reference/optionalProperties01.symbols index 95c53626f6e..57f3161c2be 100644 --- a/tests/baselines/reference/optionalProperties01.symbols +++ b/tests/baselines/reference/optionalProperties01.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties01.ts === - interface Foo { >Foo : Symbol(Foo, Decl(optionalProperties01.ts, 0, 0)) required1: string; ->required1 : Symbol(Foo.required1, Decl(optionalProperties01.ts, 1, 15)) +>required1 : Symbol(Foo.required1, Decl(optionalProperties01.ts, 0, 15)) required2: string; ->required2 : Symbol(Foo.required2, Decl(optionalProperties01.ts, 2, 20)) +>required2 : Symbol(Foo.required2, Decl(optionalProperties01.ts, 1, 20)) optional?: string; ->optional : Symbol(Foo.optional, Decl(optionalProperties01.ts, 3, 20)) +>optional : Symbol(Foo.optional, Decl(optionalProperties01.ts, 2, 20)) } const foo1 = { required1: "hello" } as Foo; ->foo1 : Symbol(foo1, Decl(optionalProperties01.ts, 7, 5)) ->required1 : Symbol(required1, Decl(optionalProperties01.ts, 7, 14)) +>foo1 : Symbol(foo1, Decl(optionalProperties01.ts, 6, 5)) +>required1 : Symbol(required1, Decl(optionalProperties01.ts, 6, 14)) >Foo : Symbol(Foo, Decl(optionalProperties01.ts, 0, 0)) const foo2 = { required1: "hello", optional: "bar" } as Foo; ->foo2 : Symbol(foo2, Decl(optionalProperties01.ts, 8, 5)) ->required1 : Symbol(required1, Decl(optionalProperties01.ts, 8, 14)) ->optional : Symbol(optional, Decl(optionalProperties01.ts, 8, 34)) +>foo2 : Symbol(foo2, Decl(optionalProperties01.ts, 7, 5)) +>required1 : Symbol(required1, Decl(optionalProperties01.ts, 7, 14)) +>optional : Symbol(optional, Decl(optionalProperties01.ts, 7, 34)) >Foo : Symbol(Foo, Decl(optionalProperties01.ts, 0, 0)) diff --git a/tests/baselines/reference/optionalProperties01.types b/tests/baselines/reference/optionalProperties01.types index 20d16d4071e..b60d87f07be 100644 --- a/tests/baselines/reference/optionalProperties01.types +++ b/tests/baselines/reference/optionalProperties01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties01.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/optionalProperties02.js b/tests/baselines/reference/optionalProperties02.js index f632c5d67a8..99e08174cd4 100644 --- a/tests/baselines/reference/optionalProperties02.js +++ b/tests/baselines/reference/optionalProperties02.js @@ -1,5 +1,4 @@ //// [optionalProperties02.ts] - interface Foo { a?: string; b: string; diff --git a/tests/baselines/reference/optionalProperties02.symbols b/tests/baselines/reference/optionalProperties02.symbols index b88f9ad7429..3c431178c0c 100644 --- a/tests/baselines/reference/optionalProperties02.symbols +++ b/tests/baselines/reference/optionalProperties02.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties02.ts === - interface Foo { >Foo : Symbol(Foo, Decl(optionalProperties02.ts, 0, 0)) a?: string; ->a : Symbol(Foo.a, Decl(optionalProperties02.ts, 1, 15)) +>a : Symbol(Foo.a, Decl(optionalProperties02.ts, 0, 15)) b: string; ->b : Symbol(Foo.b, Decl(optionalProperties02.ts, 2, 15)) +>b : Symbol(Foo.b, Decl(optionalProperties02.ts, 1, 15)) } { a: undefined }; >Foo : Symbol(Foo, Decl(optionalProperties02.ts, 0, 0)) ->a : Symbol(a, Decl(optionalProperties02.ts, 6, 6)) +>a : Symbol(a, Decl(optionalProperties02.ts, 5, 6)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/optionalProperties02.types b/tests/baselines/reference/optionalProperties02.types index 05e979b3972..afb2e8ef41b 100644 --- a/tests/baselines/reference/optionalProperties02.types +++ b/tests/baselines/reference/optionalProperties02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties02.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt b/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt index a9efb0e2971..77a221a8cbb 100644 --- a/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt +++ b/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt @@ -5,5 +5,4 @@ error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap' !!! error TS5052: Option 'mapRoot' cannot be specified without specifying option 'sourceMap'. !!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'. ==== tests/cases/compiler/optionsInlineSourceMapMapRoot.ts (0 errors) ==== - var a = 10; \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapMapRoot.js b/tests/baselines/reference/optionsInlineSourceMapMapRoot.js index c165c49ec29..f1697255293 100644 --- a/tests/baselines/reference/optionsInlineSourceMapMapRoot.js +++ b/tests/baselines/reference/optionsInlineSourceMapMapRoot.js @@ -1,7 +1,6 @@ //// [optionsInlineSourceMapMapRoot.ts] - var a = 10; //// [optionsInlineSourceMapMapRoot.js] var a = 10; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt b/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt index 66d860c22b2..20ebfade939 100644 --- a/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: optionsInlineSourceMapMapRoot.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== sourceRoot: sources: ../optionsInlineSourceMapMapRoot.ts =================================================================== @@ -16,18 +16,17 @@ sourceFile:../optionsInlineSourceMapMapRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js index 748fae7320c..2570ef236aa 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js @@ -1,7 +1,6 @@ //// [optionsInlineSourceMapSourceRoot.ts] - var a = 10; //// [optionsInlineSourceMapSourceRoot.js] var a = 10; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt index 6178766b21c..ceaa1501a59 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: optionsInlineSourceMapSourceRoot.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== sourceRoot: local/ sources: optionsInlineSourceMapSourceRoot.ts =================================================================== @@ -16,18 +16,17 @@ sourceFile:optionsInlineSourceMapSourceRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols index cf8c0826d8e..ae41cf7e2ce 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts === - var a = 10; ->a : Symbol(a, Decl(optionsInlineSourceMapSourceRoot.ts, 1, 3)) +>a : Symbol(a, Decl(optionsInlineSourceMapSourceRoot.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types index a1a47c3f975..0d7d0cf4260 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt b/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt index e91781ccd77..350de19622a 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt +++ b/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt @@ -3,5 +3,4 @@ error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMa !!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'. ==== tests/cases/compiler/optionsInlineSourceMapSourcemap.ts (0 errors) ==== - var a = 10; \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourcemap.js b/tests/baselines/reference/optionsInlineSourceMapSourcemap.js index 96d468d27da..99345352a07 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourcemap.js +++ b/tests/baselines/reference/optionsInlineSourceMapSourcemap.js @@ -1,7 +1,6 @@ //// [optionsInlineSourceMapSourcemap.ts] - var a = 10; //// [optionsInlineSourceMapSourcemap.js] var a = 10; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt b/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt index 6ca02eb22d1..b015ec502f1 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt +++ b/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: optionsInlineSourceMapSourcemap.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= sourceRoot: sources: optionsInlineSourceMapSourcemap.ts =================================================================== @@ -16,18 +16,17 @@ sourceFile:optionsInlineSourceMapSourcemap.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file diff --git a/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt b/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt index 9fa887c53b3..f68665e0d7d 100644 --- a/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt +++ b/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/optionsOutAndNoModuleGen.ts(2,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. +tests/cases/compiler/optionsOutAndNoModuleGen.ts(1,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. ==== tests/cases/compiler/optionsOutAndNoModuleGen.ts (1 errors) ==== - export var x = 10; ~~~~~~~~~~~~~~~~~~ !!! error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.js b/tests/baselines/reference/optionsSourcemapInlineSources.js index 029575ab992..a739c3a55e9 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.js +++ b/tests/baselines/reference/optionsSourcemapInlineSources.js @@ -1,5 +1,4 @@ //// [optionsSourcemapInlineSources.ts] - var a = 10; //// [optionsSourcemapInlineSources.js] diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.js.map b/tests/baselines/reference/optionsSourcemapInlineSources.js.map index 2be06332573..5f63b4b897f 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.js.map +++ b/tests/baselines/reference/optionsSourcemapInlineSources.js.map @@ -1,2 +1,2 @@ //// [optionsSourcemapInlineSources.js.map] -{"version":3,"file":"optionsSourcemapInlineSources.js","sourceRoot":"","sources":["optionsSourcemapInlineSources.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]} \ No newline at end of file +{"version":3,"file":"optionsSourcemapInlineSources.js","sourceRoot":"","sources":["optionsSourcemapInlineSources.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["var a = 10;"]} \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt b/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt index 79119d8c687..1d12bed1f40 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt +++ b/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: optionsSourcemapInlineSources.js mapUrl: optionsSourcemapInlineSources.js.map sourceRoot: sources: optionsSourcemapInlineSources.ts -sourcesContent: ["\nvar a = 10;"] +sourcesContent: ["var a = 10;"] =================================================================== ------------------------------------------------------------------- emittedFile:tests/cases/compiler/optionsSourcemapInlineSources.js @@ -17,18 +17,17 @@ sourceFile:optionsSourcemapInlineSources.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=optionsSourcemapInlineSources.js.map \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.symbols b/tests/baselines/reference/optionsSourcemapInlineSources.symbols index 50649b86a0d..db0a395bf52 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.symbols +++ b/tests/baselines/reference/optionsSourcemapInlineSources.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSources.ts === - var a = 10; ->a : Symbol(a, Decl(optionsSourcemapInlineSources.ts, 1, 3)) +>a : Symbol(a, Decl(optionsSourcemapInlineSources.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.types b/tests/baselines/reference/optionsSourcemapInlineSources.types index 1c9865777bb..410ab7729cc 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.types +++ b/tests/baselines/reference/optionsSourcemapInlineSources.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSources.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js index f7100140850..37bf30053e2 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js @@ -1,5 +1,4 @@ //// [optionsSourcemapInlineSourcesMapRoot.ts] - var a = 10; //// [optionsSourcemapInlineSourcesMapRoot.js] diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map index e99843b577f..9b9206afe11 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map @@ -1,2 +1,2 @@ //// [optionsSourcemapInlineSourcesMapRoot.js.map] -{"version":3,"file":"optionsSourcemapInlineSourcesMapRoot.js","sourceRoot":"","sources":["../optionsSourcemapInlineSourcesMapRoot.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]} \ No newline at end of file +{"version":3,"file":"optionsSourcemapInlineSourcesMapRoot.js","sourceRoot":"","sources":["../optionsSourcemapInlineSourcesMapRoot.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["var a = 10;"]} \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt index a00040a9c93..f3771739eab 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: optionsSourcemapInlineSourcesMapRoot.js mapUrl: local/optionsSourcemapInlineSourcesMapRoot.js.map sourceRoot: sources: ../optionsSourcemapInlineSourcesMapRoot.ts -sourcesContent: ["\nvar a = 10;"] +sourcesContent: ["var a = 10;"] =================================================================== ------------------------------------------------------------------- emittedFile:tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.js @@ -17,18 +17,17 @@ sourceFile:../optionsSourcemapInlineSourcesMapRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=local/optionsSourcemapInlineSourcesMapRoot.js.map \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols index 57833abe2ee..543c434cc23 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.ts === - var a = 10; ->a : Symbol(a, Decl(optionsSourcemapInlineSourcesMapRoot.ts, 1, 3)) +>a : Symbol(a, Decl(optionsSourcemapInlineSourcesMapRoot.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types index cfe881d34f5..ccc9ac38cae 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js index 948d6536f46..c793cefa473 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js @@ -1,5 +1,4 @@ //// [optionsSourcemapInlineSourcesSourceRoot.ts] - var a = 10; //// [optionsSourcemapInlineSourcesSourceRoot.js] diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map index ad373e11aab..9dd850b188d 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map @@ -1,2 +1,2 @@ //// [optionsSourcemapInlineSourcesSourceRoot.js.map] -{"version":3,"file":"optionsSourcemapInlineSourcesSourceRoot.js","sourceRoot":"local/","sources":["optionsSourcemapInlineSourcesSourceRoot.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]} \ No newline at end of file +{"version":3,"file":"optionsSourcemapInlineSourcesSourceRoot.js","sourceRoot":"local/","sources":["optionsSourcemapInlineSourcesSourceRoot.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["var a = 10;"]} \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt index 55102f5c1cd..6f00f1c51b8 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: optionsSourcemapInlineSourcesSourceRoot.js mapUrl: optionsSourcemapInlineSourcesSourceRoot.js.map sourceRoot: local/ sources: optionsSourcemapInlineSourcesSourceRoot.ts -sourcesContent: ["\nvar a = 10;"] +sourcesContent: ["var a = 10;"] =================================================================== ------------------------------------------------------------------- emittedFile:tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.js @@ -17,18 +17,17 @@ sourceFile:optionsSourcemapInlineSourcesSourceRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=optionsSourcemapInlineSourcesSourceRoot.js.map \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols index 76f2dc5fdc4..43c57f0ff5e 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.ts === - var a = 10; ->a : Symbol(a, Decl(optionsSourcemapInlineSourcesSourceRoot.ts, 1, 3)) +>a : Symbol(a, Decl(optionsSourcemapInlineSourcesSourceRoot.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types index 02226ff945a..2a96fca313c 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/out-flag2.errors.txt b/tests/baselines/reference/out-flag2.errors.txt index ea6fed45bd0..7ee3abe4c13 100644 --- a/tests/baselines/reference/out-flag2.errors.txt +++ b/tests/baselines/reference/out-flag2.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/a.ts (0 errors) ==== - class A { } ==== tests/cases/compiler/b.ts (0 errors) ==== diff --git a/tests/baselines/reference/out-flag2.js b/tests/baselines/reference/out-flag2.js index 6d452daca66..72d5b18eb54 100644 --- a/tests/baselines/reference/out-flag2.js +++ b/tests/baselines/reference/out-flag2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/out-flag2.ts] //// //// [a.ts] - class A { } //// [b.ts] diff --git a/tests/baselines/reference/out-flag2.js.map b/tests/baselines/reference/out-flag2.js.map index 2c2f112b238..781afe86d79 100644 --- a/tests/baselines/reference/out-flag2.js.map +++ b/tests/baselines/reference/out-flag2.js.map @@ -1,2 +1,2 @@ //// [c.js.map] -{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AACA;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACDX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file +{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AAAA;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACAX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/out-flag2.sourcemap.txt b/tests/baselines/reference/out-flag2.sourcemap.txt index a4966bf9f82..2867541c6ef 100644 --- a/tests/baselines/reference/out-flag2.sourcemap.txt +++ b/tests/baselines/reference/out-flag2.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:tests/cases/compiler/a.ts >>>var A = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -27,16 +26,16 @@ sourceFile:tests/cases/compiler/a.ts 3 > ^^^^^^^^^-> 1->class A { 2 > } -1->Emitted(3, 5) Source(2, 11) + SourceIndex(0) -2 >Emitted(3, 6) Source(2, 12) + SourceIndex(0) +1->Emitted(3, 5) Source(1, 11) + SourceIndex(0) +2 >Emitted(3, 6) Source(1, 12) + SourceIndex(0) --- >>> return A; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(2, 11) + SourceIndex(0) -2 >Emitted(4, 13) Source(2, 12) + SourceIndex(0) +1->Emitted(4, 5) Source(1, 11) + SourceIndex(0) +2 >Emitted(4, 13) Source(1, 12) + SourceIndex(0) --- >>>}()); 1 > @@ -48,10 +47,10 @@ sourceFile:tests/cases/compiler/a.ts 2 >} 3 > 4 > class A { } -1 >Emitted(5, 1) Source(2, 11) + SourceIndex(0) -2 >Emitted(5, 2) Source(2, 12) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(2, 12) + SourceIndex(0) +1 >Emitted(5, 1) Source(1, 11) + SourceIndex(0) +2 >Emitted(5, 2) Source(1, 12) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(1, 12) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:c.js diff --git a/tests/baselines/reference/out-flag3.errors.txt b/tests/baselines/reference/out-flag3.errors.txt index c01cef151f3..cb2c73c79d8 100644 --- a/tests/baselines/reference/out-flag3.errors.txt +++ b/tests/baselines/reference/out-flag3.errors.txt @@ -5,7 +5,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --out. !!! error TS5053: Option 'out' cannot be specified with option 'outFile'. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --out. ==== tests/cases/compiler/a.ts (0 errors) ==== - // --out and --outFile error class A { } diff --git a/tests/baselines/reference/out-flag3.js b/tests/baselines/reference/out-flag3.js index 134bbfa9e03..a2ad3272c08 100644 --- a/tests/baselines/reference/out-flag3.js +++ b/tests/baselines/reference/out-flag3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/out-flag3.ts] //// //// [a.ts] - // --out and --outFile error class A { } diff --git a/tests/baselines/reference/out-flag3.js.map b/tests/baselines/reference/out-flag3.js.map index 5fb864821b7..b5c4727d95c 100644 --- a/tests/baselines/reference/out-flag3.js.map +++ b/tests/baselines/reference/out-flag3.js.map @@ -1,2 +1,2 @@ //// [c.js.map] -{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AACA,4BAA4B;AAE5B;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACHX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file +{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAE5B;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACFX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/out-flag3.sourcemap.txt b/tests/baselines/reference/out-flag3.sourcemap.txt index 8801fd11143..c3787bbf593 100644 --- a/tests/baselines/reference/out-flag3.sourcemap.txt +++ b/tests/baselines/reference/out-flag3.sourcemap.txt @@ -11,11 +11,10 @@ sourceFile:tests/cases/compiler/a.ts >>>// --out and --outFile error 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -1 > - > +1 > 2 >// --out and --outFile error -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 29) Source(2, 29) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 29) Source(1, 29) + SourceIndex(0) --- >>>var A = (function () { 1 > @@ -23,13 +22,13 @@ sourceFile:tests/cases/compiler/a.ts 1 > > > -1 >Emitted(2, 1) Source(4, 1) + SourceIndex(0) +1 >Emitted(2, 1) Source(3, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(3, 5) Source(4, 1) + SourceIndex(0) +1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -37,16 +36,16 @@ sourceFile:tests/cases/compiler/a.ts 3 > ^^^^^^^^^-> 1->class A { 2 > } -1->Emitted(4, 5) Source(4, 11) + SourceIndex(0) -2 >Emitted(4, 6) Source(4, 12) + SourceIndex(0) +1->Emitted(4, 5) Source(3, 11) + SourceIndex(0) +2 >Emitted(4, 6) Source(3, 12) + SourceIndex(0) --- >>> return A; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(5, 5) Source(4, 11) + SourceIndex(0) -2 >Emitted(5, 13) Source(4, 12) + SourceIndex(0) +1->Emitted(5, 5) Source(3, 11) + SourceIndex(0) +2 >Emitted(5, 13) Source(3, 12) + SourceIndex(0) --- >>>}()); 1 > @@ -58,10 +57,10 @@ sourceFile:tests/cases/compiler/a.ts 2 >} 3 > 4 > class A { } -1 >Emitted(6, 1) Source(4, 11) + SourceIndex(0) -2 >Emitted(6, 2) Source(4, 12) + SourceIndex(0) -3 >Emitted(6, 2) Source(4, 1) + SourceIndex(0) -4 >Emitted(6, 6) Source(4, 12) + SourceIndex(0) +1 >Emitted(6, 1) Source(3, 11) + SourceIndex(0) +2 >Emitted(6, 2) Source(3, 12) + SourceIndex(0) +3 >Emitted(6, 2) Source(3, 1) + SourceIndex(0) +4 >Emitted(6, 6) Source(3, 12) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:c.js diff --git a/tests/baselines/reference/outModuleConcatAmd.js b/tests/baselines/reference/outModuleConcatAmd.js index fd3a4003ddf..12e5745a558 100644 --- a/tests/baselines/reference/outModuleConcatAmd.js +++ b/tests/baselines/reference/outModuleConcatAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleConcatAmd.ts] //// //// [a.ts] - export class A { } //// [b.ts] diff --git a/tests/baselines/reference/outModuleConcatAmd.js.map b/tests/baselines/reference/outModuleConcatAmd.js.map index 0e1c7d24100..93aae7a2586 100644 --- a/tests/baselines/reference/outModuleConcatAmd.js.map +++ b/tests/baselines/reference/outModuleConcatAmd.js.map @@ -1,2 +1,2 @@ //// [all.js.map] -{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;IACA;QAAA;QAAiB,CAAC;QAAD,QAAC;IAAD,CAAC,AAAlB,IAAkB;IAAL,cAAC;;;;;ICAd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file +{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAAA;QAAA;QAAiB,CAAC;QAAD,QAAC;IAAD,CAAC,AAAlB,IAAkB;IAAL,cAAC;;;;;ICCd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt b/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt index c18f4e42252..c1c1f5b5420 100644 --- a/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt +++ b/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt @@ -24,15 +24,14 @@ sourceFile:tests/cases/compiler/ref/a.ts >>> var A = (function () { 1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(14, 5) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(14, 5) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(15, 9) Source(2, 1) + SourceIndex(0) +1->Emitted(15, 9) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^^^^^ @@ -40,16 +39,16 @@ sourceFile:tests/cases/compiler/ref/a.ts 3 > ^^^^^^^^^-> 1->export class A { 2 > } -1->Emitted(16, 9) Source(2, 18) + SourceIndex(0) -2 >Emitted(16, 10) Source(2, 19) + SourceIndex(0) +1->Emitted(16, 9) Source(1, 18) + SourceIndex(0) +2 >Emitted(16, 10) Source(1, 19) + SourceIndex(0) --- >>> return A; 1->^^^^^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(17, 9) Source(2, 18) + SourceIndex(0) -2 >Emitted(17, 17) Source(2, 19) + SourceIndex(0) +1->Emitted(17, 9) Source(1, 18) + SourceIndex(0) +2 >Emitted(17, 17) Source(1, 19) + SourceIndex(0) --- >>> }()); 1 >^^^^ @@ -61,18 +60,18 @@ sourceFile:tests/cases/compiler/ref/a.ts 2 > } 3 > 4 > export class A { } -1 >Emitted(18, 5) Source(2, 18) + SourceIndex(0) -2 >Emitted(18, 6) Source(2, 19) + SourceIndex(0) -3 >Emitted(18, 6) Source(2, 1) + SourceIndex(0) -4 >Emitted(18, 10) Source(2, 19) + SourceIndex(0) +1 >Emitted(18, 5) Source(1, 18) + SourceIndex(0) +2 >Emitted(18, 6) Source(1, 19) + SourceIndex(0) +3 >Emitted(18, 6) Source(1, 1) + SourceIndex(0) +4 >Emitted(18, 10) Source(1, 19) + SourceIndex(0) --- >>> exports.A = A; 1->^^^^ 2 > ^^^^^^^^^^^^^^ 1-> 2 > A -1->Emitted(19, 5) Source(2, 14) + SourceIndex(0) -2 >Emitted(19, 19) Source(2, 15) + SourceIndex(0) +1->Emitted(19, 5) Source(1, 14) + SourceIndex(0) +2 >Emitted(19, 19) Source(1, 15) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:all.js diff --git a/tests/baselines/reference/outModuleConcatAmd.symbols b/tests/baselines/reference/outModuleConcatAmd.symbols index 349de40815a..8f2ac39afbe 100644 --- a/tests/baselines/reference/outModuleConcatAmd.symbols +++ b/tests/baselines/reference/outModuleConcatAmd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : Symbol(A, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/outModuleConcatAmd.types b/tests/baselines/reference/outModuleConcatAmd.types index 6e0d9398853..f1f7a7f12f9 100644 --- a/tests/baselines/reference/outModuleConcatAmd.types +++ b/tests/baselines/reference/outModuleConcatAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : A diff --git a/tests/baselines/reference/outModuleConcatCommonjs.errors.txt b/tests/baselines/reference/outModuleConcatCommonjs.errors.txt index d1a2adbc93f..0121cd9b9df 100644 --- a/tests/baselines/reference/outModuleConcatCommonjs.errors.txt +++ b/tests/baselines/reference/outModuleConcatCommonjs.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/ref/a.ts (0 errors) ==== - // This should be an error export class A { } diff --git a/tests/baselines/reference/outModuleConcatES6.errors.txt b/tests/baselines/reference/outModuleConcatES6.errors.txt index d1a2adbc93f..0121cd9b9df 100644 --- a/tests/baselines/reference/outModuleConcatES6.errors.txt +++ b/tests/baselines/reference/outModuleConcatES6.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/ref/a.ts (0 errors) ==== - // This should be an error export class A { } diff --git a/tests/baselines/reference/outModuleConcatSystem.js b/tests/baselines/reference/outModuleConcatSystem.js index 1648748a168..9d2a406d118 100644 --- a/tests/baselines/reference/outModuleConcatSystem.js +++ b/tests/baselines/reference/outModuleConcatSystem.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleConcatSystem.ts] //// //// [a.ts] - export class A { } //// [b.ts] diff --git a/tests/baselines/reference/outModuleConcatSystem.js.map b/tests/baselines/reference/outModuleConcatSystem.js.map index 25b706844e2..e6f76f62f05 100644 --- a/tests/baselines/reference/outModuleConcatSystem.js.map +++ b/tests/baselines/reference/outModuleConcatSystem.js.map @@ -1,2 +1,2 @@ //// [all.js.map] -{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;YACA;gBAAA;gBAAiB,CAAC;gBAAD,QAAC;YAAD,CAAC,AAAlB,IAAkB;;QAClB,CAAC;;;;;;;;;;;;;;YCDD;gBAAuB,qBAAC;gBAAxB;;gBAA2B,CAAC;gBAAD,QAAC;YAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;;QAAA,CAAC"} \ No newline at end of file +{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;YAAA;gBAAA;gBAAiB,CAAC;gBAAD,QAAC;YAAD,CAAC,AAAlB,IAAkB;;QAClB,CAAC;;;;;;;;;;;;;;YCAD;gBAAuB,qBAAC;gBAAxB;;gBAA2B,CAAC;gBAAD,QAAC;YAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;;QAAA,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt b/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt index a8dd4bb55e7..205f2cd7194 100644 --- a/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt +++ b/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt @@ -28,15 +28,14 @@ sourceFile:tests/cases/compiler/ref/a.ts >>> A = (function () { 1 >^^^^^^^^^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(18, 13) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(18, 13) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^^^^^^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(19, 17) Source(2, 1) + SourceIndex(0) +1->Emitted(19, 17) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^^^^^^^^^^^^^ @@ -44,16 +43,16 @@ sourceFile:tests/cases/compiler/ref/a.ts 3 > ^^^^^^^^^-> 1->export class A { 2 > } -1->Emitted(20, 17) Source(2, 18) + SourceIndex(0) -2 >Emitted(20, 18) Source(2, 19) + SourceIndex(0) +1->Emitted(20, 17) Source(1, 18) + SourceIndex(0) +2 >Emitted(20, 18) Source(1, 19) + SourceIndex(0) --- >>> return A; 1->^^^^^^^^^^^^^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(21, 17) Source(2, 18) + SourceIndex(0) -2 >Emitted(21, 25) Source(2, 19) + SourceIndex(0) +1->Emitted(21, 17) Source(1, 18) + SourceIndex(0) +2 >Emitted(21, 25) Source(1, 19) + SourceIndex(0) --- >>> }()); 1 >^^^^^^^^^^^^ @@ -65,10 +64,10 @@ sourceFile:tests/cases/compiler/ref/a.ts 2 > } 3 > 4 > export class A { } -1 >Emitted(22, 13) Source(2, 18) + SourceIndex(0) -2 >Emitted(22, 14) Source(2, 19) + SourceIndex(0) -3 >Emitted(22, 14) Source(2, 1) + SourceIndex(0) -4 >Emitted(22, 18) Source(2, 19) + SourceIndex(0) +1 >Emitted(22, 13) Source(1, 18) + SourceIndex(0) +2 >Emitted(22, 14) Source(1, 19) + SourceIndex(0) +3 >Emitted(22, 14) Source(1, 1) + SourceIndex(0) +4 >Emitted(22, 18) Source(1, 19) + SourceIndex(0) --- >>> exports_1("A", A); >>> } @@ -77,8 +76,8 @@ sourceFile:tests/cases/compiler/ref/a.ts 1-> > 2 > -1->Emitted(24, 9) Source(3, 1) + SourceIndex(0) -2 >Emitted(24, 10) Source(3, 2) + SourceIndex(0) +1->Emitted(24, 9) Source(2, 1) + SourceIndex(0) +2 >Emitted(24, 10) Source(2, 2) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:all.js diff --git a/tests/baselines/reference/outModuleConcatSystem.symbols b/tests/baselines/reference/outModuleConcatSystem.symbols index 349de40815a..8f2ac39afbe 100644 --- a/tests/baselines/reference/outModuleConcatSystem.symbols +++ b/tests/baselines/reference/outModuleConcatSystem.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : Symbol(A, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/outModuleConcatSystem.types b/tests/baselines/reference/outModuleConcatSystem.types index 6e0d9398853..f1f7a7f12f9 100644 --- a/tests/baselines/reference/outModuleConcatSystem.types +++ b/tests/baselines/reference/outModuleConcatSystem.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : A diff --git a/tests/baselines/reference/outModuleConcatUmd.errors.txt b/tests/baselines/reference/outModuleConcatUmd.errors.txt index 8695199c7eb..7332f41a4da 100644 --- a/tests/baselines/reference/outModuleConcatUmd.errors.txt +++ b/tests/baselines/reference/outModuleConcatUmd.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/ref/a.ts (0 errors) ==== - // This should error export class A { } diff --git a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt index 07282cd1350..6dccd8c38b0 100644 --- a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt +++ b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(2,14): error TS6131: Cannot compile modules using option 'outFile' unless the '--module' flag is 'amd' or 'system'. +tests/cases/compiler/a.ts(1,14): error TS6131: Cannot compile modules using option 'outFile' unless the '--module' flag is 'amd' or 'system'. ==== tests/cases/compiler/a.ts (1 errors) ==== - export class A { } // module ~ !!! error TS6131: Cannot compile modules using option 'outFile' unless the '--module' flag is 'amd' or 'system'. diff --git a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js index 48548400f7f..a705539797a 100644 --- a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js +++ b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleConcatUnspecifiedModuleKind.ts] //// //// [a.ts] - export class A { } // module //// [b.ts] diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.js b/tests/baselines/reference/outModuleTripleSlashRefs.js index c45414b5e62..897b698e9e7 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.js +++ b/tests/baselines/reference/outModuleTripleSlashRefs.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleTripleSlashRefs.ts] //// //// [a.ts] - /// export class A { member: typeof GlobalFoo; diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.js.map b/tests/baselines/reference/outModuleTripleSlashRefs.js.map index 8b552ec3fb3..cfa37772090 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.js.map +++ b/tests/baselines/reference/outModuleTripleSlashRefs.js.map @@ -1,2 +1,2 @@ //// [all.js.map] -{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/b.ts","tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,iCAAiC;AACjC;IAAA;IAEA,CAAC;IAAD,UAAC;AAAD,CAAC,AAFD,IAEC;;;;ICFD,+BAA+B;IAC/B;QAAA;QAEA,CAAC;QAAD,QAAC;IAAD,CAAC,AAFD,IAEC;IAFY,cAAC;;;;;ICDd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file +{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/b.ts","tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,iCAAiC;AACjC;IAAA;IAEA,CAAC;IAAD,UAAC;AAAD,CAAC,AAFD,IAEC;;;;ICHD,+BAA+B;IAC/B;QAAA;QAEA,CAAC;QAAD,QAAC;IAAD,CAAC,AAFD,IAEC;IAFY,cAAC;;;;;ICAd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt b/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt index 231da040f11..74c2a0cf798 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt +++ b/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt @@ -85,24 +85,23 @@ sourceFile:tests/cases/compiler/ref/a.ts >>> /// 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -1-> - > +1-> 2 > /// -1->Emitted(20, 5) Source(2, 1) + SourceIndex(1) -2 >Emitted(20, 36) Source(2, 32) + SourceIndex(1) +1->Emitted(20, 5) Source(1, 1) + SourceIndex(1) +2 >Emitted(20, 36) Source(1, 32) + SourceIndex(1) --- >>> var A = (function () { 1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> 1 > > -1 >Emitted(21, 5) Source(3, 1) + SourceIndex(1) +1 >Emitted(21, 5) Source(2, 1) + SourceIndex(1) --- >>> function A() { 1->^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(22, 9) Source(3, 1) + SourceIndex(1) +1->Emitted(22, 9) Source(2, 1) + SourceIndex(1) --- >>> } 1->^^^^^^^^ @@ -112,16 +111,16 @@ sourceFile:tests/cases/compiler/ref/a.ts > member: typeof GlobalFoo; > 2 > } -1->Emitted(23, 9) Source(5, 1) + SourceIndex(1) -2 >Emitted(23, 10) Source(5, 2) + SourceIndex(1) +1->Emitted(23, 9) Source(4, 1) + SourceIndex(1) +2 >Emitted(23, 10) Source(4, 2) + SourceIndex(1) --- >>> return A; 1->^^^^^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(24, 9) Source(5, 1) + SourceIndex(1) -2 >Emitted(24, 17) Source(5, 2) + SourceIndex(1) +1->Emitted(24, 9) Source(4, 1) + SourceIndex(1) +2 >Emitted(24, 17) Source(4, 2) + SourceIndex(1) --- >>> }()); 1 >^^^^ @@ -135,18 +134,18 @@ sourceFile:tests/cases/compiler/ref/a.ts 4 > export class A { > member: typeof GlobalFoo; > } -1 >Emitted(25, 5) Source(5, 1) + SourceIndex(1) -2 >Emitted(25, 6) Source(5, 2) + SourceIndex(1) -3 >Emitted(25, 6) Source(3, 1) + SourceIndex(1) -4 >Emitted(25, 10) Source(5, 2) + SourceIndex(1) +1 >Emitted(25, 5) Source(4, 1) + SourceIndex(1) +2 >Emitted(25, 6) Source(4, 2) + SourceIndex(1) +3 >Emitted(25, 6) Source(2, 1) + SourceIndex(1) +4 >Emitted(25, 10) Source(4, 2) + SourceIndex(1) --- >>> exports.A = A; 1->^^^^ 2 > ^^^^^^^^^^^^^^ 1-> 2 > A -1->Emitted(26, 5) Source(3, 14) + SourceIndex(1) -2 >Emitted(26, 19) Source(3, 15) + SourceIndex(1) +1->Emitted(26, 5) Source(2, 14) + SourceIndex(1) +2 >Emitted(26, 19) Source(2, 15) + SourceIndex(1) --- ------------------------------------------------------------------- emittedFile:all.js diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.symbols b/tests/baselines/reference/outModuleTripleSlashRefs.symbols index 5f137a95361..21d93914fb7 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.symbols +++ b/tests/baselines/reference/outModuleTripleSlashRefs.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/ref/a.ts === - /// export class A { >A : Symbol(A, Decl(a.ts, 0, 0)) member: typeof GlobalFoo; ->member : Symbol(A.member, Decl(a.ts, 2, 16)) +>member : Symbol(A.member, Decl(a.ts, 1, 16)) >GlobalFoo : Symbol(GlobalFoo, Decl(b.ts, 4, 11)) } diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.types b/tests/baselines/reference/outModuleTripleSlashRefs.types index 917704cce5a..452a7f0b11a 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.types +++ b/tests/baselines/reference/outModuleTripleSlashRefs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - /// export class A { >A : A diff --git a/tests/baselines/reference/overloadAssignmentCompat.errors.txt b/tests/baselines/reference/overloadAssignmentCompat.errors.txt index 446f9ce614f..35906ee92c9 100644 --- a/tests/baselines/reference/overloadAssignmentCompat.errors.txt +++ b/tests/baselines/reference/overloadAssignmentCompat.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/overloadAssignmentCompat.ts(35,10): error TS2394: Overload signature is not compatible with function implementation. +tests/cases/compiler/overloadAssignmentCompat.ts(34,10): error TS2394: Overload signature is not compatible with function implementation. ==== tests/cases/compiler/overloadAssignmentCompat.ts (1 errors) ==== - // ok - overload signatures are assignment compatible with their implementation class Accessor {} diff --git a/tests/baselines/reference/overloadAssignmentCompat.js b/tests/baselines/reference/overloadAssignmentCompat.js index 7915edd5446..bee754df347 100644 --- a/tests/baselines/reference/overloadAssignmentCompat.js +++ b/tests/baselines/reference/overloadAssignmentCompat.js @@ -1,5 +1,4 @@ //// [overloadAssignmentCompat.ts] - // ok - overload signatures are assignment compatible with their implementation class Accessor {} diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js index 94250b48cbc..92359d92ea8 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js @@ -1,5 +1,4 @@ //// [overloadOnConstAsTypeAnnotation.ts] - var f: (x: 'hi') => number = (x: 'hi') => { return 1; }; //// [overloadOnConstAsTypeAnnotation.js] diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols index c420e50cda2..a6d24fe9511 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts === - var f: (x: 'hi') => number = (x: 'hi') => { return 1; }; ->f : Symbol(f, Decl(overloadOnConstAsTypeAnnotation.ts, 1, 3)) ->x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 1, 8)) ->x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 1, 30)) +>f : Symbol(f, Decl(overloadOnConstAsTypeAnnotation.ts, 0, 3)) +>x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 0, 8)) +>x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 0, 30)) diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types index 382fddfb78a..5afe742dc68 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types @@ -1,5 +1,4 @@ === tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts === - var f: (x: 'hi') => number = (x: 'hi') => { return 1; }; >f : (x: "hi") => number >x : "hi" diff --git a/tests/baselines/reference/overloadResolutionTest1.errors.txt b/tests/baselines/reference/overloadResolutionTest1.errors.txt index 1bb1fb2041a..8852f863865 100644 --- a/tests/baselines/reference/overloadResolutionTest1.errors.txt +++ b/tests/baselines/reference/overloadResolutionTest1.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/overloadResolutionTest1.ts(8,16): error TS2345: Argument of type '{ a: "s"; }[]' is not assignable to parameter of type '{ a: boolean; }[]'. +tests/cases/compiler/overloadResolutionTest1.ts(7,16): error TS2345: Argument of type '{ a: "s"; }[]' is not assignable to parameter of type '{ a: boolean; }[]'. Type '{ a: "s"; }' is not assignable to type '{ a: boolean; }'. Types of property 'a' are incompatible. Type '"s"' is not assignable to type 'boolean'. -tests/cases/compiler/overloadResolutionTest1.ts(19,15): error TS2345: Argument of type '{ a: "s"; }' is not assignable to parameter of type '{ a: boolean; }'. +tests/cases/compiler/overloadResolutionTest1.ts(18,15): error TS2345: Argument of type '{ a: "s"; }' is not assignable to parameter of type '{ a: boolean; }'. Types of property 'a' are incompatible. Type '"s"' is not assignable to type 'boolean'. -tests/cases/compiler/overloadResolutionTest1.ts(25,14): error TS2345: Argument of type '{ a: boolean; }' is not assignable to parameter of type '{ a: string; }'. +tests/cases/compiler/overloadResolutionTest1.ts(24,14): error TS2345: Argument of type '{ a: boolean; }' is not assignable to parameter of type '{ a: string; }'. Types of property 'a' are incompatible. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/compiler/overloadResolutionTest1.ts (3 errors) ==== - function foo(bar:{a:number;}[]):string; function foo(bar:{a:boolean;}[]):number; function foo(bar:{a:any;}[]):any{ return bar }; diff --git a/tests/baselines/reference/overloadResolutionTest1.js b/tests/baselines/reference/overloadResolutionTest1.js index 60b99ebf7b9..228d49ec020 100644 --- a/tests/baselines/reference/overloadResolutionTest1.js +++ b/tests/baselines/reference/overloadResolutionTest1.js @@ -1,5 +1,4 @@ //// [overloadResolutionTest1.ts] - function foo(bar:{a:number;}[]):string; function foo(bar:{a:boolean;}[]):number; function foo(bar:{a:any;}[]):any{ return bar }; diff --git a/tests/baselines/reference/packageJsonMain.js b/tests/baselines/reference/packageJsonMain.js index 96509ab639e..8a545c49016 100644 --- a/tests/baselines/reference/packageJsonMain.js +++ b/tests/baselines/reference/packageJsonMain.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/moduleResolution/packageJsonMain.ts] //// //// [package.json] - { "main": "oof" } //// [oof.js] diff --git a/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt b/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt index a886fe3dca5..d7e80990bc1 100644 --- a/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt +++ b/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt @@ -7,7 +7,6 @@ !!! error TS2307: Cannot find module 'foo'. ==== /node_modules/foo/package.json (0 errors) ==== - { "main": "oof" } ==== /node_modules/foo/oof/package.json (0 errors) ==== diff --git a/tests/baselines/reference/packageJsonMain_isNonRecursive.js b/tests/baselines/reference/packageJsonMain_isNonRecursive.js index 97d7bbdf05b..61d98c81f11 100644 --- a/tests/baselines/reference/packageJsonMain_isNonRecursive.js +++ b/tests/baselines/reference/packageJsonMain_isNonRecursive.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/moduleResolution/packageJsonMain_isNonRecursive.ts] //// //// [package.json] - { "main": "oof" } //// [package.json] diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.js b/tests/baselines/reference/paramterDestrcuturingDeclaration.js index 6920f22b0d4..a969939fdc2 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.js +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.js @@ -1,5 +1,4 @@ //// [paramterDestrcuturingDeclaration.ts] - interface C { ({p: name}): any; new ({p: boolean}): any; diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols b/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols index dd11b302eea..c3ff6046bbf 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/paramterDestrcuturingDeclaration.ts === - interface C { >C : Symbol(C, Decl(paramterDestrcuturingDeclaration.ts, 0, 0)) ({p: name}): any; >p : Symbol(p) ->name : Symbol(name, Decl(paramterDestrcuturingDeclaration.ts, 2, 6)) +>name : Symbol(name, Decl(paramterDestrcuturingDeclaration.ts, 1, 6)) new ({p: boolean}): any; >p : Symbol(p) ->boolean : Symbol(boolean, Decl(paramterDestrcuturingDeclaration.ts, 3, 10)) +>boolean : Symbol(boolean, Decl(paramterDestrcuturingDeclaration.ts, 2, 10)) } diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.types b/tests/baselines/reference/paramterDestrcuturingDeclaration.types index 4b49ce22035..e71a274a6d2 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.types +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/paramterDestrcuturingDeclaration.ts === - interface C { >C : C diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt b/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt index c77d571f270..3ee2e2cfde4 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt +++ b/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,32): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,56): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(29,33): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(29,57): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(27,32): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(27,56): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,33): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,57): error TS2695: Left side of comma operator is unused and has no side effects. ==== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts (4 errors) ==== - function fun(g: (x: T) => T, x: T): T; function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; function fun(g: (x: T) => T, x: T): T { diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.js b/tests/baselines/reference/parenthesizedContexualTyping1.js index 2f1e9ff62fc..9d6bd43889f 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.js +++ b/tests/baselines/reference/parenthesizedContexualTyping1.js @@ -1,5 +1,4 @@ //// [parenthesizedContexualTyping1.ts] - function fun(g: (x: T) => T, x: T): T; function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; function fun(g: (x: T) => T, x: T): T { diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.js b/tests/baselines/reference/parenthesizedContexualTyping3.js index 6cc162a44d1..528e773e9dd 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.js +++ b/tests/baselines/reference/parenthesizedContexualTyping3.js @@ -1,5 +1,4 @@ //// [parenthesizedContexualTyping3.ts] - // Contextual typing for parenthesized substitution expressions in tagged templates. /** diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols index 1d4bce3f230..25ef572e230 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols +++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols @@ -1,12 +1,24 @@ === tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts === - // Contextual typing for parenthesized substitution expressions in tagged templates. /** * tempFun - Can't have fun for too long. */ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 5, 20)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 5, 51)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 5, 56)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 5, 67)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) + +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 6, 20)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) @@ -14,12 +26,16 @@ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 56)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 67)) +>h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 6, 67)) +>y : Symbol(y, Decl(parenthesizedContexualTyping3.ts, 6, 72)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 83)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) -function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 7, 20)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) @@ -27,88 +43,71 @@ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 56)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) ->h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 7, 67)) ->y : Symbol(y, Decl(parenthesizedContexualTyping3.ts, 7, 72)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 67)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 83)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) - -function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 8, 20)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 8, 51)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 56)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 67)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) return g(x); ->g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 8, 51)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 67)) +>g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 7, 51)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 67)) } var a = tempFun `${ x => x } ${ 10 }` ->a : Symbol(a, Decl(parenthesizedContexualTyping3.ts, 12, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19)) +>a : Symbol(a, Decl(parenthesizedContexualTyping3.ts, 11, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 11, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 11, 19)) var b = tempFun `${ (x => x) } ${ 10 }` ->b : Symbol(b, Decl(parenthesizedContexualTyping3.ts, 13, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21)) +>b : Symbol(b, Decl(parenthesizedContexualTyping3.ts, 12, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 21)) var c = tempFun `${ ((x => x)) } ${ 10 }` ->c : Symbol(c, Decl(parenthesizedContexualTyping3.ts, 14, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22)) +>c : Symbol(c, Decl(parenthesizedContexualTyping3.ts, 13, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 22)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 22)) var d = tempFun `${ x => x } ${ x => x } ${ 10 }` ->d : Symbol(d, Decl(parenthesizedContexualTyping3.ts, 15, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31)) +>d : Symbol(d, Decl(parenthesizedContexualTyping3.ts, 14, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 31)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 31)) var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }` ->e : Symbol(e, Decl(parenthesizedContexualTyping3.ts, 16, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33)) +>e : Symbol(e, Decl(parenthesizedContexualTyping3.ts, 15, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 33)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 33)) var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }` ->f : Symbol(f, Decl(parenthesizedContexualTyping3.ts, 17, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34)) +>f : Symbol(f, Decl(parenthesizedContexualTyping3.ts, 16, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 34)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 34)) var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }` ->g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 18, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37)) +>g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 17, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 37)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 37)) var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }` ->h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 19, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37)) +>h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 18, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.types b/tests/baselines/reference/parenthesizedContexualTyping3.types index 522228b260d..a7d927537e2 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.types +++ b/tests/baselines/reference/parenthesizedContexualTyping3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts === - // Contextual typing for parenthesized substitution expressions in tagged templates. /** diff --git a/tests/baselines/reference/parseTypes.errors.txt b/tests/baselines/reference/parseTypes.errors.txt index 184137fe220..aca1ddff313 100644 --- a/tests/baselines/reference/parseTypes.errors.txt +++ b/tests/baselines/reference/parseTypes.errors.txt @@ -1,13 +1,12 @@ +tests/cases/compiler/parseTypes.ts(8,1): error TS2322: Type '(s: string) => void' is not assignable to type '() => number'. tests/cases/compiler/parseTypes.ts(9,1): error TS2322: Type '(s: string) => void' is not assignable to type '() => number'. -tests/cases/compiler/parseTypes.ts(10,1): error TS2322: Type '(s: string) => void' is not assignable to type '() => number'. -tests/cases/compiler/parseTypes.ts(11,1): error TS2322: Type '(s: string) => void' is not assignable to type '{ [x: number]: number; }'. +tests/cases/compiler/parseTypes.ts(10,1): error TS2322: Type '(s: string) => void' is not assignable to type '{ [x: number]: number; }'. Index signature is missing in type '(s: string) => void'. -tests/cases/compiler/parseTypes.ts(12,1): error TS2322: Type '(s: string) => void' is not assignable to type 'new () => number'. +tests/cases/compiler/parseTypes.ts(11,1): error TS2322: Type '(s: string) => void' is not assignable to type 'new () => number'. Type '(s: string) => void' provides no match for the signature 'new (): number'. ==== tests/cases/compiler/parseTypes.ts (4 errors) ==== - var x = <() => number>null; var y = <{(): number; }>null; var z = <{new(): number; }>null diff --git a/tests/baselines/reference/parseTypes.js b/tests/baselines/reference/parseTypes.js index 08cc9f2a6bd..8d6c0c943bc 100644 --- a/tests/baselines/reference/parseTypes.js +++ b/tests/baselines/reference/parseTypes.js @@ -1,5 +1,4 @@ //// [parseTypes.ts] - var x = <() => number>null; var y = <{(): number; }>null; var z = <{new(): number; }>null diff --git a/tests/baselines/reference/parser10.1.1-8gs.errors.txt b/tests/baselines/reference/parser10.1.1-8gs.errors.txt index 75ab54029a6..84e45644e94 100644 --- a/tests/baselines/reference/parser10.1.1-8gs.errors.txt +++ b/tests/baselines/reference/parser10.1.1-8gs.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,7): error TS2304: Cannot find name 'NotEarlyError'. -tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(18,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode. +tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'. +tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode. ==== tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts (2 errors) ==== - /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/baselines/reference/parser10.1.1-8gs.js b/tests/baselines/reference/parser10.1.1-8gs.js index fb3b96f6baf..e7d342cf1f1 100644 --- a/tests/baselines/reference/parser10.1.1-8gs.js +++ b/tests/baselines/reference/parser10.1.1-8gs.js @@ -1,5 +1,4 @@ //// [parser10.1.1-8gs.ts] - /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/baselines/reference/parser768531.js b/tests/baselines/reference/parser768531.js index 462db3742b3..26e22117717 100644 --- a/tests/baselines/reference/parser768531.js +++ b/tests/baselines/reference/parser768531.js @@ -1,5 +1,4 @@ //// [parser768531.ts] - {a: 3} /x/ diff --git a/tests/baselines/reference/parser768531.symbols b/tests/baselines/reference/parser768531.symbols index f180922c7e0..2da2298c8e2 100644 --- a/tests/baselines/reference/parser768531.symbols +++ b/tests/baselines/reference/parser768531.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts === - -No type information for this code.{a: 3} +{a: 3} No type information for this code./x/ No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/parser768531.types b/tests/baselines/reference/parser768531.types index 17bae7161fa..e4b8e1eb70d 100644 --- a/tests/baselines/reference/parser768531.types +++ b/tests/baselines/reference/parser768531.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts === - {a: 3} >a : any >3 : 3 diff --git a/tests/baselines/reference/parserClass2.errors.txt b/tests/baselines/reference/parserClass2.errors.txt index 6bd60fc84d7..938cba9aa6a 100644 --- a/tests/baselines/reference/parserClass2.errors.txt +++ b/tests/baselines/reference/parserClass2.errors.txt @@ -1,11 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(3,43): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(4,37): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(5,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(1,43): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(2,37): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(3,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. ==== tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts (3 errors) ==== - - export class LoggerAdapter implements ILogger { ~~~~~~~ !!! error TS2304: Cannot find name 'ILogger'. diff --git a/tests/baselines/reference/parserClass2.js b/tests/baselines/reference/parserClass2.js index 0d47a388acc..80c1fd8ff6a 100644 --- a/tests/baselines/reference/parserClass2.js +++ b/tests/baselines/reference/parserClass2.js @@ -1,6 +1,4 @@ //// [parserClass2.ts] - - export class LoggerAdapter implements ILogger { constructor (public logger: ILogger) { this._information = this.logger.information(); diff --git a/tests/baselines/reference/parserEnum1.js b/tests/baselines/reference/parserEnum1.js index 43cdc626ab8..10f24cc8601 100644 --- a/tests/baselines/reference/parserEnum1.js +++ b/tests/baselines/reference/parserEnum1.js @@ -1,6 +1,4 @@ //// [parserEnum1.ts] - - export enum SignatureFlags { None = 0, IsIndexer = 1, diff --git a/tests/baselines/reference/parserEnum1.symbols b/tests/baselines/reference/parserEnum1.symbols index ec9a3d8aa21..ef245464c6e 100644 --- a/tests/baselines/reference/parserEnum1.symbols +++ b/tests/baselines/reference/parserEnum1.symbols @@ -1,18 +1,16 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum1.ts === - - export enum SignatureFlags { >SignatureFlags : Symbol(SignatureFlags, Decl(parserEnum1.ts, 0, 0)) None = 0, ->None : Symbol(SignatureFlags.None, Decl(parserEnum1.ts, 2, 32)) +>None : Symbol(SignatureFlags.None, Decl(parserEnum1.ts, 0, 32)) IsIndexer = 1, ->IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum1.ts, 3, 17)) +>IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum1.ts, 1, 17)) IsStringIndexer = 1 << 1, ->IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum1.ts, 4, 22)) +>IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum1.ts, 2, 22)) IsNumberIndexer = 1 << 2, ->IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum1.ts, 5, 33)) +>IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum1.ts, 3, 33)) } diff --git a/tests/baselines/reference/parserEnum1.types b/tests/baselines/reference/parserEnum1.types index 42161656a1e..5543a336463 100644 --- a/tests/baselines/reference/parserEnum1.types +++ b/tests/baselines/reference/parserEnum1.types @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum1.ts === - - export enum SignatureFlags { >SignatureFlags : SignatureFlags diff --git a/tests/baselines/reference/parserEnum2.js b/tests/baselines/reference/parserEnum2.js index 0fa0633d280..b1f28f6c502 100644 --- a/tests/baselines/reference/parserEnum2.js +++ b/tests/baselines/reference/parserEnum2.js @@ -1,6 +1,4 @@ //// [parserEnum2.ts] - - export enum SignatureFlags { None = 0, IsIndexer = 1, diff --git a/tests/baselines/reference/parserEnum2.symbols b/tests/baselines/reference/parserEnum2.symbols index dc745ca726e..85fff2cfdbc 100644 --- a/tests/baselines/reference/parserEnum2.symbols +++ b/tests/baselines/reference/parserEnum2.symbols @@ -1,18 +1,16 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum2.ts === - - export enum SignatureFlags { >SignatureFlags : Symbol(SignatureFlags, Decl(parserEnum2.ts, 0, 0)) None = 0, ->None : Symbol(SignatureFlags.None, Decl(parserEnum2.ts, 2, 32)) +>None : Symbol(SignatureFlags.None, Decl(parserEnum2.ts, 0, 32)) IsIndexer = 1, ->IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum2.ts, 3, 17)) +>IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum2.ts, 1, 17)) IsStringIndexer = 1 << 1, ->IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum2.ts, 4, 22)) +>IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum2.ts, 2, 22)) IsNumberIndexer = 1 << 2 ->IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum2.ts, 5, 33)) +>IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum2.ts, 3, 33)) } diff --git a/tests/baselines/reference/parserEnum2.types b/tests/baselines/reference/parserEnum2.types index 5c0a8fec2d4..d21420a0320 100644 --- a/tests/baselines/reference/parserEnum2.types +++ b/tests/baselines/reference/parserEnum2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum2.ts === - - export enum SignatureFlags { >SignatureFlags : SignatureFlags diff --git a/tests/baselines/reference/parserEnum3.js b/tests/baselines/reference/parserEnum3.js index b9b9e743e4b..3e559591128 100644 --- a/tests/baselines/reference/parserEnum3.js +++ b/tests/baselines/reference/parserEnum3.js @@ -1,6 +1,4 @@ //// [parserEnum3.ts] - - export enum SignatureFlags { } diff --git a/tests/baselines/reference/parserEnum3.symbols b/tests/baselines/reference/parserEnum3.symbols index 01e55693335..6189bf17abf 100644 --- a/tests/baselines/reference/parserEnum3.symbols +++ b/tests/baselines/reference/parserEnum3.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum3.ts === - - export enum SignatureFlags { >SignatureFlags : Symbol(SignatureFlags, Decl(parserEnum3.ts, 0, 0)) } diff --git a/tests/baselines/reference/parserEnum3.types b/tests/baselines/reference/parserEnum3.types index 21527136b32..29cdea8ef68 100644 --- a/tests/baselines/reference/parserEnum3.types +++ b/tests/baselines/reference/parserEnum3.types @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum3.ts === - - export enum SignatureFlags { >SignatureFlags : SignatureFlags } diff --git a/tests/baselines/reference/parserEnum4.errors.txt b/tests/baselines/reference/parserEnum4.errors.txt index d9a57b21daa..e919ff3678d 100644 --- a/tests/baselines/reference/parserEnum4.errors.txt +++ b/tests/baselines/reference/parserEnum4.errors.txt @@ -1,9 +1,7 @@ -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum4.ts(4,9): error TS1132: Enum member expected. +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum4.ts(2,9): error TS1132: Enum member expected. ==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum4.ts (1 errors) ==== - - export enum SignatureFlags { , ~ diff --git a/tests/baselines/reference/parserEnum4.js b/tests/baselines/reference/parserEnum4.js index 96d3c8757ed..90919ed8347 100644 --- a/tests/baselines/reference/parserEnum4.js +++ b/tests/baselines/reference/parserEnum4.js @@ -1,6 +1,4 @@ //// [parserEnum4.ts] - - export enum SignatureFlags { , } diff --git a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt index e34e8b6072a..eb32618af4b 100644 --- a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt +++ b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,54): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,56): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,56): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,105): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,54): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,56): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,56): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,105): error TS1005: ';' expected. ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts (4 errors) ==== - var texCoords = [2, 2, 0.5000001192092895, 0.8749999 ; 403953552, 0.5000001192092895, 0.8749999403953552]; ~ !!! error TS1005: ',' expected. diff --git a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js index c366c750cc7..ff590b1681c 100644 --- a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js +++ b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js @@ -1,5 +1,4 @@ //// [parserErrorRecoveryArrayLiteralExpression3.ts] - var texCoords = [2, 2, 0.5000001192092895, 0.8749999 ; 403953552, 0.5000001192092895, 0.8749999403953552]; diff --git a/tests/baselines/reference/parserVariableDeclaration1.errors.txt b/tests/baselines/reference/parserVariableDeclaration1.errors.txt index 3011eb73123..e0617e2b159 100644 --- a/tests/baselines/reference/parserVariableDeclaration1.errors.txt +++ b/tests/baselines/reference/parserVariableDeclaration1.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(2,19): error TS2304: Cannot find name 'a'. -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(3,15): error TS2304: Cannot find name 'b'. -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(4,12): error TS2304: Cannot find name 'c'. -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(5,14): error TS2304: Cannot find name 'd'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(1,19): error TS2304: Cannot find name 'a'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(2,15): error TS2304: Cannot find name 'b'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(3,12): error TS2304: Cannot find name 'c'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(4,14): error TS2304: Cannot find name 'd'. ==== tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts (4 errors) ==== - var selection = a, ~ !!! error TS2304: Cannot find name 'a'. diff --git a/tests/baselines/reference/parserVariableDeclaration1.js b/tests/baselines/reference/parserVariableDeclaration1.js index 48bf07ebdb3..4ecddf8099a 100644 --- a/tests/baselines/reference/parserVariableDeclaration1.js +++ b/tests/baselines/reference/parserVariableDeclaration1.js @@ -1,5 +1,4 @@ //// [parserVariableDeclaration1.ts] - var selection = a, position = b, model = c, diff --git a/tests/baselines/reference/parser_breakTarget3.js b/tests/baselines/reference/parser_breakTarget3.js index 91ba9fb5993..0eceba87bf8 100644 --- a/tests/baselines/reference/parser_breakTarget3.js +++ b/tests/baselines/reference/parser_breakTarget3.js @@ -1,5 +1,4 @@ //// [parser_breakTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_breakTarget3.symbols b/tests/baselines/reference/parser_breakTarget3.symbols index 35184471d4d..99ec413987a 100644 --- a/tests/baselines/reference/parser_breakTarget3.symbols +++ b/tests/baselines/reference/parser_breakTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target1; diff --git a/tests/baselines/reference/parser_breakTarget3.types b/tests/baselines/reference/parser_breakTarget3.types index eb5c2cf68a5..997c7a52502 100644 --- a/tests/baselines/reference/parser_breakTarget3.types +++ b/tests/baselines/reference/parser_breakTarget3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_breakTarget4.js b/tests/baselines/reference/parser_breakTarget4.js index 4516cf3e8f9..c6cadb5efa1 100644 --- a/tests/baselines/reference/parser_breakTarget4.js +++ b/tests/baselines/reference/parser_breakTarget4.js @@ -1,5 +1,4 @@ //// [parser_breakTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_breakTarget4.symbols b/tests/baselines/reference/parser_breakTarget4.symbols index f4d4b2e4bff..042df67d9b2 100644 --- a/tests/baselines/reference/parser_breakTarget4.symbols +++ b/tests/baselines/reference/parser_breakTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target2; diff --git a/tests/baselines/reference/parser_breakTarget4.types b/tests/baselines/reference/parser_breakTarget4.types index 3a368eeb6c9..7aab34998cc 100644 --- a/tests/baselines/reference/parser_breakTarget4.types +++ b/tests/baselines/reference/parser_breakTarget4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_continueTarget3.js b/tests/baselines/reference/parser_continueTarget3.js index ea1559346de..76a98a0e204 100644 --- a/tests/baselines/reference/parser_continueTarget3.js +++ b/tests/baselines/reference/parser_continueTarget3.js @@ -1,5 +1,4 @@ //// [parser_continueTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_continueTarget3.symbols b/tests/baselines/reference/parser_continueTarget3.symbols index c522444ca1a..2038671d215 100644 --- a/tests/baselines/reference/parser_continueTarget3.symbols +++ b/tests/baselines/reference/parser_continueTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target1; diff --git a/tests/baselines/reference/parser_continueTarget3.types b/tests/baselines/reference/parser_continueTarget3.types index 273c47f97cf..33675260207 100644 --- a/tests/baselines/reference/parser_continueTarget3.types +++ b/tests/baselines/reference/parser_continueTarget3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_continueTarget4.js b/tests/baselines/reference/parser_continueTarget4.js index 9ccaaac27e7..795cab2e2ad 100644 --- a/tests/baselines/reference/parser_continueTarget4.js +++ b/tests/baselines/reference/parser_continueTarget4.js @@ -1,5 +1,4 @@ //// [parser_continueTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_continueTarget4.symbols b/tests/baselines/reference/parser_continueTarget4.symbols index b7e770f9bf9..2b47099715e 100644 --- a/tests/baselines/reference/parser_continueTarget4.symbols +++ b/tests/baselines/reference/parser_continueTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target2; diff --git a/tests/baselines/reference/parser_continueTarget4.types b/tests/baselines/reference/parser_continueTarget4.types index 21381823e7c..3f67b31f715 100644 --- a/tests/baselines/reference/parser_continueTarget4.types +++ b/tests/baselines/reference/parser_continueTarget4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_duplicateLabel3.js b/tests/baselines/reference/parser_duplicateLabel3.js index c2ea2769f18..9bd6c56356a 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.js +++ b/tests/baselines/reference/parser_duplicateLabel3.js @@ -1,5 +1,4 @@ //// [parser_duplicateLabel3.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/parser_duplicateLabel3.symbols b/tests/baselines/reference/parser_duplicateLabel3.symbols index 7e238eb2916..20627a0e2b8 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.symbols +++ b/tests/baselines/reference/parser_duplicateLabel3.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts === - target: while (true) { function f() { ->f : Symbol(f, Decl(parser_duplicateLabel3.ts, 2, 14)) +>f : Symbol(f, Decl(parser_duplicateLabel3.ts, 1, 14)) target: while (true) { diff --git a/tests/baselines/reference/parser_duplicateLabel3.types b/tests/baselines/reference/parser_duplicateLabel3.types index 8d62ee2a14d..13e51b760d9 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.types +++ b/tests/baselines/reference/parser_duplicateLabel3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts === - target: >target : any diff --git a/tests/baselines/reference/parser_duplicateLabel4.js b/tests/baselines/reference/parser_duplicateLabel4.js index a9491314426..569a9bcd102 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.js +++ b/tests/baselines/reference/parser_duplicateLabel4.js @@ -1,5 +1,4 @@ //// [parser_duplicateLabel4.ts] - target: while (true) { } diff --git a/tests/baselines/reference/parser_duplicateLabel4.symbols b/tests/baselines/reference/parser_duplicateLabel4.symbols index e7123de1600..564531bf71b 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.symbols +++ b/tests/baselines/reference/parser_duplicateLabel4.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts === - -No type information for this code.target: +target: No type information for this code.while (true) { No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/parser_duplicateLabel4.types b/tests/baselines/reference/parser_duplicateLabel4.types index 483cf8a0051..f14c79f4314 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.types +++ b/tests/baselines/reference/parser_duplicateLabel4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts === - target: >target : any diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js index 8b81ff506fe..09951a17010 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js +++ b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js @@ -1,5 +1,4 @@ //// [partiallyAnnotatedFunctionWitoutTypeParameter.ts] - // simple case declare function simple(f: (a: number, b: number) => void): {} diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols index a7ed6b67d83..aafbcb8271c 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols +++ b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/types/contextualTypes/partiallyAnnotatedFunction/partiallyAnnotatedFunctionWitoutTypeParameter.ts === - // simple case declare function simple(f: (a: number, b: number) => void): {} >simple : Symbol(simple, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 0, 0)) ->f : Symbol(f, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 2, 24)) ->a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 2, 28)) ->b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 2, 38)) +>f : Symbol(f, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 1, 24)) +>a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 1, 28)) +>b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 1, 38)) simple((a: number, b) => {}) >simple : Symbol(simple, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 0, 0)) ->a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 8)) ->b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 18)) +>a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 3, 8)) +>b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 3, 18)) simple((a, b: number) => {}) >simple : Symbol(simple, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 0, 0)) ->a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 5, 8)) ->b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 5, 10)) +>a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 8)) +>b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 10)) diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types index f07cd5a8928..1e37636ed9e 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types +++ b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/partiallyAnnotatedFunction/partiallyAnnotatedFunctionWitoutTypeParameter.ts === - // simple case declare function simple(f: (a: number, b: number) => void): {} >simple : (f: (a: number, b: number) => void) => {} diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js index 8809efa963a..16ef9260e8d 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/pathMappingBasedModuleResolution3_classic.ts] //// //// [file1.ts] - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols index 97ec40d4cb4..41e36accb1c 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols @@ -1,18 +1,17 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) declare function use(a: any): void; ->use : Symbol(use, Decl(file1.ts, 3, 31)) ->a : Symbol(a, Decl(file1.ts, 4, 21)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) +>a : Symbol(a, Decl(file1.ts, 3, 21)) use(x.toExponential()); ->use : Symbol(use, Decl(file1.ts, 3, 31)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) >x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) === c:/root/folder2/file2.ts === diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types index 17f93932265..140a84768cf 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types @@ -1,5 +1,4 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js index cd0eb7d7794..f4dc1dd2674 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/pathMappingBasedModuleResolution3_node.ts] //// //// [file1.ts] - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols index 487dea2fb89..de7155bef85 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols @@ -1,18 +1,17 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) declare function use(a: any): void; ->use : Symbol(use, Decl(file1.ts, 3, 31)) ->a : Symbol(a, Decl(file1.ts, 4, 21)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) +>a : Symbol(a, Decl(file1.ts, 3, 21)) use(x.toExponential()); ->use : Symbol(use, Decl(file1.ts, 3, 31)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) >x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) === c:/root/folder2/file2.ts === diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types index 2c85b8ebcbd..ecfa2bea736 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types @@ -1,5 +1,4 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js index a91cc9d8d5a..3a31b8cd950 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/pathMappingBasedModuleResolution_withExtension.ts] //// //// [foo.ts] - export function foo() {} //// [bar.js] diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols index 717660067ec..355122b65e9 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols @@ -6,7 +6,6 @@ import { bar } from "bar"; >bar : Symbol(bar, Decl(a.ts, 1, 8)) === /foo/foo.ts === - export function foo() {} >foo : Symbol(foo, Decl(foo.ts, 0, 0)) diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types index 8d7c57b1d27..a48c48acfc8 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types @@ -6,7 +6,6 @@ import { bar } from "bar"; >bar : () => void === /foo/foo.ts === - export function foo() {} >foo : () => void diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt index 7578f730c33..4b038b99bcc 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt @@ -1,8 +1,7 @@ -/a.ts(2,21): error TS2307: Cannot find module 'foo'. +/a.ts(1,21): error TS2307: Cannot find module 'foo'. ==== /a.ts (1 errors) ==== - import { foo } from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js index 4fded4a78ad..e40fe32f46b 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js @@ -1,5 +1,4 @@ //// [a.ts] - import { foo } from "foo"; diff --git a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js index d51c2624b1c..79de4636f52 100644 --- a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js +++ b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js @@ -1,5 +1,4 @@ //// [prefixUnaryOperatorsOnExportedVariables.ts] - export var x = false; export var y = 1; if (!x) { diff --git a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols index c8293ef1902..4773921a3be 100644 --- a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols +++ b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/prefixUnaryOperatorsOnExportedVariables.ts === - export var x = false; ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) export var y = 1; ->y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 2, 10)) +>y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) if (!x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (+x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (-x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (~x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (void x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (typeof x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (++y) { ->y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 2, 10)) +>y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) } diff --git a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types index 41df41af51b..42763ee46bd 100644 --- a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types +++ b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types @@ -1,5 +1,4 @@ === tests/cases/compiler/prefixUnaryOperatorsOnExportedVariables.ts === - export var x = false; >x : boolean >false : false diff --git a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt index debb5808493..67a62a2269c 100644 --- a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt +++ b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt @@ -10,34 +10,33 @@ tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4039 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(9,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(15,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(21,16): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(27,9): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(117,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(121,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(161,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(164,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(167,16): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(170,9): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(176,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(178,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(211,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(217,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(223,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(229,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(319,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(323,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(363,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(366,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(369,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(372,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(8,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(14,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(20,16): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(26,9): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(116,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(120,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(160,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(163,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(166,16): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(169,9): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(175,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(177,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(210,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(216,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(222,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(228,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(318,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(322,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(362,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(365,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(368,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(371,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(377,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(379,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (24 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyAccessorDeclFile.js b/tests/baselines/reference/privacyAccessorDeclFile.js index 9d077d19e06..9d92ba0d684 100644 --- a/tests/baselines/reference/privacyAccessorDeclFile.js +++ b/tests/baselines/reference/privacyAccessorDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyAccessorDeclFile.ts] //// //// [privacyAccessorDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt index b5d0ea8223e..6c1763f293e 100644 --- a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt +++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt @@ -110,7 +110,6 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error } } ==== tests/cases/compiler/privacyCannotNameAccessorDeclFile_GlobalWidgets.ts (0 errors) ==== - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js index d19869b0f03..c2a781f9b69 100644 --- a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js +++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyCannotNameAccessorDeclFile.ts] //// //// [privacyCannotNameAccessorDeclFile_GlobalWidgets.ts] - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt index e76474d2d33..f11937efb0c 100644 --- a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt @@ -85,8 +85,6 @@ tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(38,12): error var privateVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2(); var privateVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4(); ==== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts (0 errors) ==== - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js index df24bf70259..9da4e922f77 100644 --- a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js +++ b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/privacyCannotNameVarTypeDeclFile.ts] //// //// [privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts] - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt index dd44005047e..56ca5158e07 100644 --- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt +++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt @@ -1,14 +1,13 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(17,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(20,63): error TS2690: A class must be declared after its base class. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,69): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,69): error TS2690: A class must be declared after its base class. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(64,55): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(19,63): error TS2690: A class must be declared after its base class. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(21,69): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(21,69): error TS2690: A class must be declared after its base class. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(63,55): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(68,65): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (6 errors) ==== - export module publicModule { export class publicClassInPublicModule { private f1() { diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js index 2803006c5b5..857d52e99bf 100644 --- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js +++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts] //// //// [privacyClassExtendsClauseDeclFile_externalModule.ts] - export module publicModule { export class publicClassInPublicModule { private f1() { diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt index 2681ee0e20e..586d4530c8e 100644 --- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt +++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt @@ -1,13 +1,12 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(15,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(20,79): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(23,78): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(63,65): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,75): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(19,79): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(22,78): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(62,65): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(67,75): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (5 errors) ==== - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js index 3d78f2a8048..f4d48aae39d 100644 --- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js +++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts] //// //// [privacyClassImplementsClauseDeclFile_externalModule.ts] - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt index 76fd8b4e80a..432e209eaa8 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt @@ -177,8 +177,6 @@ tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts( function privateFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) { } ==== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts (0 errors) ==== - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js index 00314bdceab..6b0ea3cafd2 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js +++ b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile.ts] //// //// [privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts] - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt index bc6229815f5..1a915d8b82c 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt @@ -148,8 +148,6 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error } ==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts (0 errors) ==== - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js index 2124f8fbb24..61c7e0014db 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js +++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/privacyFunctionCannotNameReturnTypeDeclFile.ts] //// //// [privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts] - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt index 0e88e08e645..8367483ca97 100644 --- a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt @@ -18,50 +18,49 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): err tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(11,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(33,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(37,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,54): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,83): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(84,63): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(93,78): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(101,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(104,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(106,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,67): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,109): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(111,70): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(113,85): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(143,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(165,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(169,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(216,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(225,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(233,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(236,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(238,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(8,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(32,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(36,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(40,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(40,54): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(40,83): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(83,63): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(92,78): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(98,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(103,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(105,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(107,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(107,67): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(107,109): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(110,70): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(112,85): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(140,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(164,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(168,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(172,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(172,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(172,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(215,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(224,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(230,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(235,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(237,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(242,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(244,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (40 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.js b/tests/baselines/reference/privacyFunctionParameterDeclFile.js index 255b8d68db6..db00fb67d8a 100644 --- a/tests/baselines/reference/privacyFunctionParameterDeclFile.js +++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyFunctionParameterDeclFile.ts] //// //// [privacyFunctionParameterDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt index 0156c7241f7..94c8b20311c 100644 --- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt @@ -20,54 +20,53 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(462,9): err tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(466,70): error TS4060: Return type of exported function has or is using private name 'privateModule'. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(469,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(472,85): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(11,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(12,17): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(37,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(43,23): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(49,12): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(55,5): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(144,59): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(156,17): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(169,74): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(175,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(176,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(177,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(178,17): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(181,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(184,23): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(187,12): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(190,5): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(194,66): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(197,17): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(200,81): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(238,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(239,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(240,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(241,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(266,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(272,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(278,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(284,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(373,63): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(385,21): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(398,78): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(404,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(405,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(406,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(407,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(410,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(413,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(416,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(419,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(423,70): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(426,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(8,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(11,17): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(36,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(42,23): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(48,12): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(54,5): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(143,59): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(155,17): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(168,74): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(174,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(175,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(176,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(177,17): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(180,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(183,23): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(186,12): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(189,5): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(193,66): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(196,17): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(199,81): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(237,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(238,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(239,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(240,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(265,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(271,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(277,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(283,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(372,63): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(384,21): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(397,78): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(403,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(404,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(405,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(406,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(409,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(412,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(415,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(418,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(422,70): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(425,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(428,85): error TS4060: Return type of exported function has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (44 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js index 1aba74efaa4..d3136f4310e 100644 --- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js +++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyFunctionReturnTypeDeclFile.ts] //// //// [privacyFunctionReturnTypeDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt index 2107e773173..0669d3c3d26 100644 --- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt +++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt @@ -1,13 +1,12 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(15,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(20,84): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(23,83): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(63,70): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,80): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(19,84): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(22,83): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(62,70): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(67,80): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (5 errors) ==== - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js index 6d2748dd8dc..cb25b2b5ff9 100644 --- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js +++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts] //// //// [privacyInterfaceExtendsClauseDeclFile_externalModule.ts] - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt index cc81762bce3..c657347043f 100644 --- a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt +++ b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt @@ -26,7 +26,6 @@ tests/cases/compiler/privacyTopLevelAmbientExternalModuleImportWithoutExport_cor !!! error TS2323: Cannot redeclare exported variable 'publicUse_im_private_mi_public'. ==== tests/cases/compiler/privacyTopLevelAmbientExternalModuleImportWithoutExport_require.ts (0 errors) ==== - // Public elements export class c_public { foo: string; diff --git a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js index 13b7de58ecf..de464ddd11a 100644 --- a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js +++ b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyTopLevelAmbientExternalModuleImportWithoutExport.ts] //// //// [privacyTopLevelAmbientExternalModuleImportWithoutExport_require.ts] - // Public elements export class c_public { foo: string; diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt index 1fbf8f7bac9..d7f8e5abc01 100644 --- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt +++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(52,31): error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,31): error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,32): error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(50,31): error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(54,31): error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,32): error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'. ==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts (5 errors) ==== - // private elements module m_private { export class c_private { diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js index 85a6cc3691a..8646cbe6f75 100644 --- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js +++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js @@ -1,5 +1,4 @@ //// [privacyTopLevelInternalReferenceImportWithoutExport.ts] - // private elements module m_private { export class c_private { diff --git a/tests/baselines/reference/privacyVarDeclFile.errors.txt b/tests/baselines/reference/privacyVarDeclFile.errors.txt index 6ae5373e0c7..c6ee30d6630 100644 --- a/tests/baselines/reference/privacyVarDeclFile.errors.txt +++ b/tests/baselines/reference/privacyVarDeclFile.errors.txt @@ -8,30 +8,29 @@ tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(162,40): error TS4028: Pub tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(163,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(165,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(166,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(9,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(25,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(27,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(52,47): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(57,62): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(63,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(66,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(67,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(69,53): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(70,68): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(90,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(106,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(108,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(133,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(138,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(144,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(148,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(8,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(24,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(26,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(51,47): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(56,62): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(62,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(65,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(66,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(68,53): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(69,68): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(89,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(105,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(107,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(132,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(137,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(143,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(146,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(149,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (20 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyVarDeclFile.js b/tests/baselines/reference/privacyVarDeclFile.js index eab99747849..b32fac91085 100644 --- a/tests/baselines/reference/privacyVarDeclFile.js +++ b/tests/baselines/reference/privacyVarDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyVarDeclFile.ts] //// //// [privacyVarDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/promiseTest.js b/tests/baselines/reference/promiseTest.js index db554197499..dcac778aff6 100644 --- a/tests/baselines/reference/promiseTest.js +++ b/tests/baselines/reference/promiseTest.js @@ -1,5 +1,4 @@ //// [promiseTest.ts] - interface Promise { then(success?: (value: T) => Promise): Promise; then(success?: (value: T) => B): Promise; diff --git a/tests/baselines/reference/promiseTest.symbols b/tests/baselines/reference/promiseTest.symbols index f28348cca45..4030f122a61 100644 --- a/tests/baselines/reference/promiseTest.symbols +++ b/tests/baselines/reference/promiseTest.symbols @@ -1,55 +1,54 @@ === tests/cases/compiler/promiseTest.ts === - interface Promise { >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) then(success?: (value: T) => Promise): Promise; ->then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->A : Symbol(A, Decl(promiseTest.ts, 2, 9)) ->success : Symbol(success, Decl(promiseTest.ts, 2, 12)) ->value : Symbol(value, Decl(promiseTest.ts, 2, 23)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>A : Symbol(A, Decl(promiseTest.ts, 1, 9)) +>success : Symbol(success, Decl(promiseTest.ts, 1, 12)) +>value : Symbol(value, Decl(promiseTest.ts, 1, 23)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->A : Symbol(A, Decl(promiseTest.ts, 2, 9)) +>A : Symbol(A, Decl(promiseTest.ts, 1, 9)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->A : Symbol(A, Decl(promiseTest.ts, 2, 9)) +>A : Symbol(A, Decl(promiseTest.ts, 1, 9)) then(success?: (value: T) => B): Promise; ->then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->B : Symbol(B, Decl(promiseTest.ts, 3, 9)) ->success : Symbol(success, Decl(promiseTest.ts, 3, 12)) ->value : Symbol(value, Decl(promiseTest.ts, 3, 23)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) ->B : Symbol(B, Decl(promiseTest.ts, 3, 9)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>B : Symbol(B, Decl(promiseTest.ts, 2, 9)) +>success : Symbol(success, Decl(promiseTest.ts, 2, 12)) +>value : Symbol(value, Decl(promiseTest.ts, 2, 23)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) +>B : Symbol(B, Decl(promiseTest.ts, 2, 9)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->B : Symbol(B, Decl(promiseTest.ts, 3, 9)) +>B : Symbol(B, Decl(promiseTest.ts, 2, 9)) data: T; ->data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) +>data : Symbol(Promise.data, Decl(promiseTest.ts, 2, 51)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) } var p: Promise = null; ->p : Symbol(p, Decl(promiseTest.ts, 7, 3)) +>p : Symbol(p, Decl(promiseTest.ts, 6, 3)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) var p2 = p.then(function (x) { ->p2 : Symbol(p2, Decl(promiseTest.ts, 8, 3)) ->p.then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->p : Symbol(p, Decl(promiseTest.ts, 7, 3)) ->then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->x : Symbol(x, Decl(promiseTest.ts, 8, 26)) +>p2 : Symbol(p2, Decl(promiseTest.ts, 7, 3)) +>p.then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>p : Symbol(p, Decl(promiseTest.ts, 6, 3)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>x : Symbol(x, Decl(promiseTest.ts, 7, 26)) return p; ->p : Symbol(p, Decl(promiseTest.ts, 7, 3)) +>p : Symbol(p, Decl(promiseTest.ts, 6, 3)) } ); var x = p2.data; // number ->x : Symbol(x, Decl(promiseTest.ts, 12, 3)) ->p2.data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51)) ->p2 : Symbol(p2, Decl(promiseTest.ts, 8, 3)) ->data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51)) +>x : Symbol(x, Decl(promiseTest.ts, 11, 3)) +>p2.data : Symbol(Promise.data, Decl(promiseTest.ts, 2, 51)) +>p2 : Symbol(p2, Decl(promiseTest.ts, 7, 3)) +>data : Symbol(Promise.data, Decl(promiseTest.ts, 2, 51)) diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types index d69e1efeb42..b9166a1af25 100644 --- a/tests/baselines/reference/promiseTest.types +++ b/tests/baselines/reference/promiseTest.types @@ -1,5 +1,4 @@ === tests/cases/compiler/promiseTest.ts === - interface Promise { >Promise : Promise >T : T diff --git a/tests/baselines/reference/properties.js b/tests/baselines/reference/properties.js index fc103423529..70bb62dd09d 100644 --- a/tests/baselines/reference/properties.js +++ b/tests/baselines/reference/properties.js @@ -1,5 +1,4 @@ //// [properties.ts] - class MyClass { public get Count(): number diff --git a/tests/baselines/reference/properties.js.map b/tests/baselines/reference/properties.js.map index b9820ddba7c..47c17f796c9 100644 --- a/tests/baselines/reference/properties.js.map +++ b/tests/baselines/reference/properties.js.map @@ -1,2 +1,2 @@ //// [properties.js.map] -{"version":3,"file":"properties.js","sourceRoot":"","sources":["properties.ts"],"names":[],"mappings":"AACA;IAAA;IAWA,CAAC;IATG,sBAAW,0BAAK;aAAhB;YAEI,MAAM,CAAC,EAAE,CAAC;QACd,CAAC;aAED,UAAiB,KAAa;YAE1B,EAAE;QACN,CAAC;;;OALA;IAML,cAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file +{"version":3,"file":"properties.js","sourceRoot":"","sources":["properties.ts"],"names":[],"mappings":"AAAA;IAAA;IAWA,CAAC;IATG,sBAAW,0BAAK;aAAhB;YAEI,MAAM,CAAC,EAAE,CAAC;QACd,CAAC;aAED,UAAiB,KAAa;YAE1B,EAAE;QACN,CAAC;;;OALA;IAML,cAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file diff --git a/tests/baselines/reference/properties.sourcemap.txt b/tests/baselines/reference/properties.sourcemap.txt index 8c99154125a..0afa8514e66 100644 --- a/tests/baselines/reference/properties.sourcemap.txt +++ b/tests/baselines/reference/properties.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:properties.ts >>>var MyClass = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function MyClass() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -38,8 +37,8 @@ sourceFile:properties.ts > } > 2 > } -1->Emitted(3, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(13, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(12, 2) + SourceIndex(0) --- >>> Object.defineProperty(MyClass.prototype, "Count", { 1->^^^^ @@ -48,15 +47,15 @@ sourceFile:properties.ts 1-> 2 > public get 3 > Count -1->Emitted(4, 5) Source(4, 5) + SourceIndex(0) -2 >Emitted(4, 27) Source(4, 16) + SourceIndex(0) -3 >Emitted(4, 53) Source(4, 21) + SourceIndex(0) +1->Emitted(4, 5) Source(3, 5) + SourceIndex(0) +2 >Emitted(4, 27) Source(3, 16) + SourceIndex(0) +3 >Emitted(4, 53) Source(3, 21) + SourceIndex(0) --- >>> get: function () { 1 >^^^^^^^^^^^^^ 2 > ^^^^^^^^^^-> 1 > -1 >Emitted(5, 14) Source(4, 5) + SourceIndex(0) +1 >Emitted(5, 14) Source(3, 5) + SourceIndex(0) --- >>> return 42; 1->^^^^^^^^^^^^ @@ -71,11 +70,11 @@ sourceFile:properties.ts 3 > 4 > 42 5 > ; -1->Emitted(6, 13) Source(6, 9) + SourceIndex(0) -2 >Emitted(6, 19) Source(6, 15) + SourceIndex(0) -3 >Emitted(6, 20) Source(6, 16) + SourceIndex(0) -4 >Emitted(6, 22) Source(6, 18) + SourceIndex(0) -5 >Emitted(6, 23) Source(6, 19) + SourceIndex(0) +1->Emitted(6, 13) Source(5, 9) + SourceIndex(0) +2 >Emitted(6, 19) Source(5, 15) + SourceIndex(0) +3 >Emitted(6, 20) Source(5, 16) + SourceIndex(0) +4 >Emitted(6, 22) Source(5, 18) + SourceIndex(0) +5 >Emitted(6, 23) Source(5, 19) + SourceIndex(0) --- >>> }, 1 >^^^^^^^^ @@ -84,8 +83,8 @@ sourceFile:properties.ts 1 > > 2 > } -1 >Emitted(7, 9) Source(7, 5) + SourceIndex(0) -2 >Emitted(7, 10) Source(7, 6) + SourceIndex(0) +1 >Emitted(7, 9) Source(6, 5) + SourceIndex(0) +2 >Emitted(7, 10) Source(6, 6) + SourceIndex(0) --- >>> set: function (value) { 1->^^^^^^^^^^^^^ @@ -96,9 +95,9 @@ sourceFile:properties.ts > 2 > public set Count( 3 > value: number -1->Emitted(8, 14) Source(9, 5) + SourceIndex(0) -2 >Emitted(8, 24) Source(9, 22) + SourceIndex(0) -3 >Emitted(8, 29) Source(9, 35) + SourceIndex(0) +1->Emitted(8, 14) Source(8, 5) + SourceIndex(0) +2 >Emitted(8, 24) Source(8, 22) + SourceIndex(0) +3 >Emitted(8, 29) Source(8, 35) + SourceIndex(0) --- >>> // 1 >^^^^^^^^^^^^ @@ -107,8 +106,8 @@ sourceFile:properties.ts > { > 2 > // -1 >Emitted(9, 13) Source(11, 9) + SourceIndex(0) -2 >Emitted(9, 15) Source(11, 11) + SourceIndex(0) +1 >Emitted(9, 13) Source(10, 9) + SourceIndex(0) +2 >Emitted(9, 15) Source(10, 11) + SourceIndex(0) --- >>> }, 1 >^^^^^^^^ @@ -117,8 +116,8 @@ sourceFile:properties.ts 1 > > 2 > } -1 >Emitted(10, 9) Source(12, 5) + SourceIndex(0) -2 >Emitted(10, 10) Source(12, 6) + SourceIndex(0) +1 >Emitted(10, 9) Source(11, 5) + SourceIndex(0) +2 >Emitted(10, 10) Source(11, 6) + SourceIndex(0) --- >>> enumerable: true, >>> configurable: true @@ -126,7 +125,7 @@ sourceFile:properties.ts 1->^^^^^^^ 2 > ^^^^^^^^^^^^^-> 1-> -1->Emitted(13, 8) Source(7, 6) + SourceIndex(0) +1->Emitted(13, 8) Source(6, 6) + SourceIndex(0) --- >>> return MyClass; 1->^^^^ @@ -139,8 +138,8 @@ sourceFile:properties.ts > } > 2 > } -1->Emitted(14, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(14, 19) Source(13, 2) + SourceIndex(0) +1->Emitted(14, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(14, 19) Source(12, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -163,9 +162,9 @@ sourceFile:properties.ts > // > } > } -1 >Emitted(15, 1) Source(13, 1) + SourceIndex(0) -2 >Emitted(15, 2) Source(13, 2) + SourceIndex(0) -3 >Emitted(15, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(15, 6) Source(13, 2) + SourceIndex(0) +1 >Emitted(15, 1) Source(12, 1) + SourceIndex(0) +2 >Emitted(15, 2) Source(12, 2) + SourceIndex(0) +3 >Emitted(15, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(15, 6) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=properties.js.map \ No newline at end of file diff --git a/tests/baselines/reference/properties.symbols b/tests/baselines/reference/properties.symbols index c322e5ecfb2..06980901d13 100644 --- a/tests/baselines/reference/properties.symbols +++ b/tests/baselines/reference/properties.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/properties.ts === - class MyClass >MyClass : Symbol(MyClass, Decl(properties.ts, 0, 0)) { public get Count(): number ->Count : Symbol(MyClass.Count, Decl(properties.ts, 2, 1), Decl(properties.ts, 6, 5)) +>Count : Symbol(MyClass.Count, Decl(properties.ts, 1, 1), Decl(properties.ts, 5, 5)) { return 42; } public set Count(value: number) ->Count : Symbol(MyClass.Count, Decl(properties.ts, 2, 1), Decl(properties.ts, 6, 5)) ->value : Symbol(value, Decl(properties.ts, 8, 21)) +>Count : Symbol(MyClass.Count, Decl(properties.ts, 1, 1), Decl(properties.ts, 5, 5)) +>value : Symbol(value, Decl(properties.ts, 7, 21)) { // } diff --git a/tests/baselines/reference/properties.types b/tests/baselines/reference/properties.types index 99ff875a087..f7440709cd7 100644 --- a/tests/baselines/reference/properties.types +++ b/tests/baselines/reference/properties.types @@ -1,5 +1,4 @@ === tests/cases/compiler/properties.ts === - class MyClass >MyClass : MyClass { diff --git a/tests/baselines/reference/propertyAssignment.errors.txt b/tests/baselines/reference/propertyAssignment.errors.txt index a8411ca490c..6aa34c15ac9 100644 --- a/tests/baselines/reference/propertyAssignment.errors.txt +++ b/tests/baselines/reference/propertyAssignment.errors.txt @@ -1,14 +1,12 @@ -tests/cases/compiler/propertyAssignment.ts(6,13): error TS1170: A computed property name in a type literal must directly refer to a built-in symbol. -tests/cases/compiler/propertyAssignment.ts(6,14): error TS2304: Cannot find name 'index'. -tests/cases/compiler/propertyAssignment.ts(14,1): error TS2322: Type '{ x: number; }' is not assignable to type 'new () => any'. +tests/cases/compiler/propertyAssignment.ts(4,13): error TS1170: A computed property name in a type literal must directly refer to a built-in symbol. +tests/cases/compiler/propertyAssignment.ts(4,14): error TS2304: Cannot find name 'index'. +tests/cases/compiler/propertyAssignment.ts(12,1): error TS2322: Type '{ x: number; }' is not assignable to type 'new () => any'. Type '{ x: number; }' provides no match for the signature 'new (): any'. -tests/cases/compiler/propertyAssignment.ts(16,1): error TS2322: Type '{ x: number; }' is not assignable to type '() => void'. +tests/cases/compiler/propertyAssignment.ts(14,1): error TS2322: Type '{ x: number; }' is not assignable to type '() => void'. Type '{ x: number; }' provides no match for the signature '(): void'. ==== tests/cases/compiler/propertyAssignment.ts (4 errors) ==== - - var foo1: { new ():any; } var bar1: { x : number; } diff --git a/tests/baselines/reference/propertyAssignment.js b/tests/baselines/reference/propertyAssignment.js index 9aa99c8b561..979d0afc9c3 100644 --- a/tests/baselines/reference/propertyAssignment.js +++ b/tests/baselines/reference/propertyAssignment.js @@ -1,6 +1,4 @@ //// [propertyAssignment.ts] - - var foo1: { new ():any; } var bar1: { x : number; } diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt index 0bf38477f70..de11681331b 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinNestedSubclass.ts(25,28): error TS2339: Property 'z' does not exist on type 'C'. +tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinNestedSubclass.ts(24,28): error TS2339: Property 'z' does not exist on type 'C'. ==== tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinNestedSubclass.ts (1 errors) ==== - class B { protected x: string; protected static x: string; diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js index 47d329909fd..f15f9a5b669 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js @@ -1,5 +1,4 @@ //// [protectedClassPropertyAccessibleWithinNestedSubclass.ts] - class B { protected x: string; protected static x: string; diff --git a/tests/baselines/reference/protoAssignment.errors.txt b/tests/baselines/reference/protoAssignment.errors.txt index 37c443ba74e..5a46a96b33d 100644 --- a/tests/baselines/reference/protoAssignment.errors.txt +++ b/tests/baselines/reference/protoAssignment.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/protoAssignment.ts(2,26): error TS2304: Cannot find name 'Comparable'. +tests/cases/compiler/protoAssignment.ts(1,26): error TS2304: Cannot find name 'Comparable'. ==== tests/cases/compiler/protoAssignment.ts (1 errors) ==== - interface Number extends Comparable { ~~~~~~~~~~ !!! error TS2304: Cannot find name 'Comparable'. diff --git a/tests/baselines/reference/protoAssignment.js b/tests/baselines/reference/protoAssignment.js index a1fe983d296..5b5c822e567 100644 --- a/tests/baselines/reference/protoAssignment.js +++ b/tests/baselines/reference/protoAssignment.js @@ -1,5 +1,4 @@ //// [protoAssignment.ts] - interface Number extends Comparable { compareTo(other: number); diff --git a/tests/baselines/reference/reExportDefaultExport.js b/tests/baselines/reference/reExportDefaultExport.js index cd306e411d5..ef9386da32a 100644 --- a/tests/baselines/reference/reExportDefaultExport.js +++ b/tests/baselines/reference/reExportDefaultExport.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/reExportDefaultExport.ts] //// //// [m1.ts] - export default function f() { } export {f}; diff --git a/tests/baselines/reference/reExportDefaultExport.symbols b/tests/baselines/reference/reExportDefaultExport.symbols index cd0d6e493c9..a4ebfdc0ac5 100644 --- a/tests/baselines/reference/reExportDefaultExport.symbols +++ b/tests/baselines/reference/reExportDefaultExport.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f() { >f : Symbol(f, Decl(m1.ts, 0, 0)) } export {f}; ->f : Symbol(f, Decl(m1.ts, 3, 8)) +>f : Symbol(f, Decl(m1.ts, 2, 8)) === tests/cases/conformance/es6/modules/m2.ts === diff --git a/tests/baselines/reference/reExportDefaultExport.types b/tests/baselines/reference/reExportDefaultExport.types index f775571ac2c..09fce8c7365 100644 --- a/tests/baselines/reference/reExportDefaultExport.types +++ b/tests/baselines/reference/reExportDefaultExport.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f() { >f : () => void } diff --git a/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt index 0d83d8b94ee..13d3ca9cfe6 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/file2.ts(11,9): error TS2661: Cannot export 'b'. Only local ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare var x: number; declare var x1: number; declare let {a, b}: {a: number, b: number}; diff --git a/tests/baselines/reference/reExportGlobalDeclaration1.js b/tests/baselines/reference/reExportGlobalDeclaration1.js index 9ab432fd084..334d20de214 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration1.js +++ b/tests/baselines/reference/reExportGlobalDeclaration1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration1.ts] //// //// [file1.d.ts] - declare var x: number; declare var x1: number; declare let {a, b}: {a: number, b: number}; diff --git a/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt index b24a52aff49..608c77fed10 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/file2.ts(4,9): error TS2661: Cannot export 'I2'. Only local ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare interface I1 { x: number } diff --git a/tests/baselines/reference/reExportGlobalDeclaration2.js b/tests/baselines/reference/reExportGlobalDeclaration2.js index 52e55bb18c4..5e58bf4b68a 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration2.js +++ b/tests/baselines/reference/reExportGlobalDeclaration2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration2.ts] //// //// [file1.d.ts] - declare interface I1 { x: number } diff --git a/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt index 2f469e80491..436c4f0be91 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/file2.ts(4,9): error TS2661: Cannot export 'NS2'. Only loca ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare namespace NS1 { export var foo: number; } diff --git a/tests/baselines/reference/reExportGlobalDeclaration3.js b/tests/baselines/reference/reExportGlobalDeclaration3.js index ed111b42197..0cd5132049d 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration3.js +++ b/tests/baselines/reference/reExportGlobalDeclaration3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration3.ts] //// //// [file1.d.ts] - declare namespace NS1 { export var foo: number; } diff --git a/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt index a3b58a276ae..d4d6031d78b 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/file2.ts(4,9): error TS2661: Cannot export 'Cls2'. Only loc ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare class Cls1 { x: number } diff --git a/tests/baselines/reference/reExportGlobalDeclaration4.js b/tests/baselines/reference/reExportGlobalDeclaration4.js index a7a0e7525ca..d860d20b83c 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration4.js +++ b/tests/baselines/reference/reExportGlobalDeclaration4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration4.ts] //// //// [file1.d.ts] - declare class Cls1 { x: number } diff --git a/tests/baselines/reference/reExportUndefined1.errors.txt b/tests/baselines/reference/reExportUndefined1.errors.txt index 5042b4c4c0c..f0284383aca 100644 --- a/tests/baselines/reference/reExportUndefined1.errors.txt +++ b/tests/baselines/reference/reExportUndefined1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(2,10): error TS2661: Cannot export 'undefined'. Only local declarations can be exported from a module. +tests/cases/compiler/a.ts(1,10): error TS2661: Cannot export 'undefined'. Only local declarations can be exported from a module. ==== tests/cases/compiler/a.ts (1 errors) ==== - export { undefined }; ~~~~~~~~~ !!! error TS2661: Cannot export 'undefined'. Only local declarations can be exported from a module. \ No newline at end of file diff --git a/tests/baselines/reference/reExportUndefined1.js b/tests/baselines/reference/reExportUndefined1.js index 7540901fa30..3dfacd62df2 100644 --- a/tests/baselines/reference/reExportUndefined1.js +++ b/tests/baselines/reference/reExportUndefined1.js @@ -1,5 +1,4 @@ //// [a.ts] - export { undefined }; //// [a.js] diff --git a/tests/baselines/reference/reExportUndefined2.js b/tests/baselines/reference/reExportUndefined2.js index bde88442b33..49aacf98e6a 100644 --- a/tests/baselines/reference/reExportUndefined2.js +++ b/tests/baselines/reference/reExportUndefined2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportUndefined2.ts] //// //// [a.ts] - var undefined; export { undefined }; diff --git a/tests/baselines/reference/reExportUndefined2.symbols b/tests/baselines/reference/reExportUndefined2.symbols index c4f532ed6dc..dbef6e66ee0 100644 --- a/tests/baselines/reference/reExportUndefined2.symbols +++ b/tests/baselines/reference/reExportUndefined2.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.ts === - var undefined; ->undefined : Symbol(undefined, Decl(a.ts, 1, 3)) +>undefined : Symbol(undefined, Decl(a.ts, 0, 3)) export { undefined }; ->undefined : Symbol(undefined, Decl(a.ts, 2, 8)) +>undefined : Symbol(undefined, Decl(a.ts, 1, 8)) === tests/cases/compiler/b.ts === import { undefined } from "./a"; diff --git a/tests/baselines/reference/reExportUndefined2.types b/tests/baselines/reference/reExportUndefined2.types index d3f3dc9d726..e6d5db146eb 100644 --- a/tests/baselines/reference/reExportUndefined2.types +++ b/tests/baselines/reference/reExportUndefined2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - var undefined; >undefined : any diff --git a/tests/baselines/reference/reachabilityChecks1.errors.txt b/tests/baselines/reference/reachabilityChecks1.errors.txt index 18a453969a1..0f1a9b7bb1e 100644 --- a/tests/baselines/reference/reachabilityChecks1.errors.txt +++ b/tests/baselines/reference/reachabilityChecks1.errors.txt @@ -1,14 +1,13 @@ -tests/cases/compiler/reachabilityChecks1.ts(3,1): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(7,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(19,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(31,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(48,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(61,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(70,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(2,1): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(6,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(18,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(30,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(47,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(60,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(69,5): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks1.ts (7 errors) ==== - while (true); var x = 1; ~~~ diff --git a/tests/baselines/reference/reachabilityChecks1.js b/tests/baselines/reference/reachabilityChecks1.js index 97b914fc104..61bb2b42996 100644 --- a/tests/baselines/reference/reachabilityChecks1.js +++ b/tests/baselines/reference/reachabilityChecks1.js @@ -1,5 +1,4 @@ //// [reachabilityChecks1.ts] - while (true); var x = 1; diff --git a/tests/baselines/reference/reachabilityChecks2.errors.txt b/tests/baselines/reference/reachabilityChecks2.errors.txt index cd48f84f8e1..9061effeb66 100644 --- a/tests/baselines/reference/reachabilityChecks2.errors.txt +++ b/tests/baselines/reference/reachabilityChecks2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/reachabilityChecks2.ts(5,1): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks2.ts(4,1): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks2.ts (1 errors) ==== - while (true) { } const enum E { X } diff --git a/tests/baselines/reference/reachabilityChecks2.js b/tests/baselines/reference/reachabilityChecks2.js index a17b51b4ca6..f5f8245bbe6 100644 --- a/tests/baselines/reference/reachabilityChecks2.js +++ b/tests/baselines/reference/reachabilityChecks2.js @@ -1,5 +1,4 @@ //// [reachabilityChecks2.ts] - while (true) { } const enum E { X } diff --git a/tests/baselines/reference/reachabilityChecks3.errors.txt b/tests/baselines/reference/reachabilityChecks3.errors.txt index 1114f245f44..7e95a24c65e 100644 --- a/tests/baselines/reference/reachabilityChecks3.errors.txt +++ b/tests/baselines/reference/reachabilityChecks3.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/reachabilityChecks3.ts(3,1): error TS7028: Unused label. -tests/cases/compiler/reachabilityChecks3.ts(12,5): error TS7028: Unused label. -tests/cases/compiler/reachabilityChecks3.ts(15,17): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(2,1): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(11,5): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(14,17): error TS7028: Unused label. ==== tests/cases/compiler/reachabilityChecks3.ts (3 errors) ==== - let x = 1; loop: while (true) { ~~~~ diff --git a/tests/baselines/reference/reachabilityChecks3.js b/tests/baselines/reference/reachabilityChecks3.js index dd22453938d..5672e7ac1ed 100644 --- a/tests/baselines/reference/reachabilityChecks3.js +++ b/tests/baselines/reference/reachabilityChecks3.js @@ -1,5 +1,4 @@ //// [reachabilityChecks3.ts] - let x = 1; loop: while (true) { if (x == 100) { diff --git a/tests/baselines/reference/reachabilityChecks4.errors.txt b/tests/baselines/reference/reachabilityChecks4.errors.txt index ba9519462e7..fdbb9d23ee8 100644 --- a/tests/baselines/reference/reachabilityChecks4.errors.txt +++ b/tests/baselines/reference/reachabilityChecks4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/reachabilityChecks4.ts(7,9): error TS7029: Fallthrough case in switch. +tests/cases/compiler/reachabilityChecks4.ts(6,9): error TS7029: Fallthrough case in switch. ==== tests/cases/compiler/reachabilityChecks4.ts (1 errors) ==== - function foo(x, y) { switch (x) { case 1: diff --git a/tests/baselines/reference/reachabilityChecks4.js b/tests/baselines/reference/reachabilityChecks4.js index 588644c5a05..de84c445cff 100644 --- a/tests/baselines/reference/reachabilityChecks4.js +++ b/tests/baselines/reference/reachabilityChecks4.js @@ -1,5 +1,4 @@ //// [reachabilityChecks4.ts] - function foo(x, y) { switch (x) { case 1: diff --git a/tests/baselines/reference/reachabilityChecks5.errors.txt b/tests/baselines/reference/reachabilityChecks5.errors.txt index 4a894261a3d..4dc7c1705f1 100644 --- a/tests/baselines/reference/reachabilityChecks5.errors.txt +++ b/tests/baselines/reference/reachabilityChecks5.errors.txt @@ -1,18 +1,17 @@ -tests/cases/compiler/reachabilityChecks5.ts(6,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(19,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/compiler/reachabilityChecks5.ts(31,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(41,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(52,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(80,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(86,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks5.ts(94,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(97,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks5.ts(116,18): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(123,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(5,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(18,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/reachabilityChecks5.ts(30,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(40,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(51,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(79,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(85,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(93,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(96,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(115,18): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(122,13): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks5.ts (11 errors) ==== - function f0(x): number { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks5.js b/tests/baselines/reference/reachabilityChecks5.js index a6c507ac87b..947b11b48c5 100644 --- a/tests/baselines/reference/reachabilityChecks5.js +++ b/tests/baselines/reference/reachabilityChecks5.js @@ -1,5 +1,4 @@ //// [reachabilityChecks5.ts] - function f0(x): number { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks6.errors.txt b/tests/baselines/reference/reachabilityChecks6.errors.txt index 24832d9ab38..9dadf3b2d6f 100644 --- a/tests/baselines/reference/reachabilityChecks6.errors.txt +++ b/tests/baselines/reference/reachabilityChecks6.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/reachabilityChecks6.ts(6,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(31,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(41,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(52,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(80,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(86,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks6.ts(94,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(97,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks6.ts(116,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(123,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks6.ts(5,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(30,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(40,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(51,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(79,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(85,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks6.ts(93,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(96,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks6.ts(115,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(122,13): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks6.ts (10 errors) ==== - function f0(x) { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks6.js b/tests/baselines/reference/reachabilityChecks6.js index 9be23d32048..169d3f74866 100644 --- a/tests/baselines/reference/reachabilityChecks6.js +++ b/tests/baselines/reference/reachabilityChecks6.js @@ -1,5 +1,4 @@ //// [reachabilityChecks6.ts] - function f0(x) { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks7.errors.txt b/tests/baselines/reference/reachabilityChecks7.errors.txt index 1596c7d9a3b..9ac2d0c1ad8 100644 --- a/tests/baselines/reference/reachabilityChecks7.errors.txt +++ b/tests/baselines/reference/reachabilityChecks7.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/reachabilityChecks7.ts(14,16): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks7.ts(18,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/reachabilityChecks7.ts(13,16): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks7.ts(17,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/compiler/reachabilityChecks7.ts (2 errors) ==== - // async function without return type annotation - error async function f1() { } diff --git a/tests/baselines/reference/reachabilityChecks7.js b/tests/baselines/reference/reachabilityChecks7.js index c17472205a4..30addff4aec 100644 --- a/tests/baselines/reference/reachabilityChecks7.js +++ b/tests/baselines/reference/reachabilityChecks7.js @@ -1,5 +1,4 @@ //// [reachabilityChecks7.ts] - // async function without return type annotation - error async function f1() { } diff --git a/tests/baselines/reference/reactImportDropped.js b/tests/baselines/reference/reactImportDropped.js index 7ada76b42f4..53ff422fa6e 100644 --- a/tests/baselines/reference/reactImportDropped.js +++ b/tests/baselines/reference/reactImportDropped.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reactImportDropped.ts] //// //// [react.d.ts] - export = React; export as namespace React; diff --git a/tests/baselines/reference/reactImportDropped.symbols b/tests/baselines/reference/reactImportDropped.symbols index 0daa49353fa..71c25480c72 100644 --- a/tests/baselines/reference/reactImportDropped.symbols +++ b/tests/baselines/reference/reactImportDropped.symbols @@ -1,45 +1,44 @@ === tests/cases/compiler/react.d.ts === - export = React; ->React : Symbol(React, Decl(react.d.ts, 2, 26)) +>React : Symbol(React, Decl(react.d.ts, 1, 26)) export as namespace React; ->React : Symbol(React, Decl(react.d.ts, 1, 15)) +>React : Symbol(React, Decl(react.d.ts, 0, 15)) declare namespace React { ->React : Symbol(React, Decl(react.d.ts, 2, 26)) +>React : Symbol(React, Decl(react.d.ts, 1, 26)) function createClass(spec: any): ClassicComponentClass; ->createClass : Symbol(createClass, Decl(react.d.ts, 4, 25)) ->spec : Symbol(spec, Decl(react.d.ts, 6, 25)) ->ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59)) +>createClass : Symbol(createClass, Decl(react.d.ts, 3, 25)) +>spec : Symbol(spec, Decl(react.d.ts, 5, 25)) +>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 5, 59)) interface ClassicComponentClass { ->ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59)) +>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 5, 59)) new (props?: any): ClassicComponentClass; ->props : Symbol(props, Decl(react.d.ts, 9, 13)) ->ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59)) +>props : Symbol(props, Decl(react.d.ts, 8, 13)) +>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 5, 59)) } } declare global { ->global : Symbol(global, Decl(react.d.ts, 11, 1)) +>global : Symbol(global, Decl(react.d.ts, 10, 1)) namespace JSX { ->JSX : Symbol(JSX, Decl(react.d.ts, 13, 16)) +>JSX : Symbol(JSX, Decl(react.d.ts, 12, 16)) interface ElementAttributesProperty { } ->ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(react.d.ts, 14, 19)) +>ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(react.d.ts, 13, 19)) } } === tests/cases/compiler/src/components/TabBar.js === export default React.createClass({ ->React.createClass : Symbol(React.createClass, Decl(react.d.ts, 4, 25)) ->React : Symbol(React, Decl(react.d.ts, 1, 15)) ->createClass : Symbol(React.createClass, Decl(react.d.ts, 4, 25)) +>React.createClass : Symbol(React.createClass, Decl(react.d.ts, 3, 25)) +>React : Symbol(React, Decl(react.d.ts, 0, 15)) +>createClass : Symbol(React.createClass, Decl(react.d.ts, 3, 25)) render() { >render : Symbol(render, Decl(TabBar.js, 0, 34)) diff --git a/tests/baselines/reference/reactImportDropped.types b/tests/baselines/reference/reactImportDropped.types index 36f1a6a4779..ae8b1308c03 100644 --- a/tests/baselines/reference/reactImportDropped.types +++ b/tests/baselines/reference/reactImportDropped.types @@ -1,5 +1,4 @@ === tests/cases/compiler/react.d.ts === - export = React; >React : typeof React diff --git a/tests/baselines/reference/reactNamespaceImportPresevation.js b/tests/baselines/reference/reactNamespaceImportPresevation.js index 682dd0f7882..a3e9ac800fe 100644 --- a/tests/baselines/reference/reactNamespaceImportPresevation.js +++ b/tests/baselines/reference/reactNamespaceImportPresevation.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reactNamespaceImportPresevation.tsx] //// //// [modules.d.ts] - declare module "my-React-Lib" { var a: any; export = a; diff --git a/tests/baselines/reference/reactNamespaceImportPresevation.symbols b/tests/baselines/reference/reactNamespaceImportPresevation.symbols index caeca7cefcb..dadd6f3e7a7 100644 --- a/tests/baselines/reference/reactNamespaceImportPresevation.symbols +++ b/tests/baselines/reference/reactNamespaceImportPresevation.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modules.d.ts === - declare module "my-React-Lib" { var a: any; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) export = a; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) } === tests/cases/compiler/test.tsx === diff --git a/tests/baselines/reference/reactNamespaceImportPresevation.types b/tests/baselines/reference/reactNamespaceImportPresevation.types index 931a86d248d..9f45b5cb462 100644 --- a/tests/baselines/reference/reactNamespaceImportPresevation.types +++ b/tests/baselines/reference/reactNamespaceImportPresevation.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modules.d.ts === - declare module "my-React-Lib" { var a: any; >a : any diff --git a/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt b/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt index 2e72775fe9c..721279e561d 100644 --- a/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt +++ b/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt @@ -1,10 +1,9 @@ error TS5059: Invalid value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier. -tests/cases/compiler/reactNamespaceInvalidInput.tsx(2,2): error TS2304: Cannot find name 'my-React-Lib'. +tests/cases/compiler/reactNamespaceInvalidInput.tsx(1,2): error TS2304: Cannot find name 'my-React-Lib'. !!! error TS5059: Invalid value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier. ==== tests/cases/compiler/reactNamespaceInvalidInput.tsx (1 errors) ==== - ; ~~~ !!! error TS2304: Cannot find name 'my-React-Lib'. diff --git a/tests/baselines/reference/reactNamespaceInvalidInput.js b/tests/baselines/reference/reactNamespaceInvalidInput.js index 69918fe976f..44502ccf167 100644 --- a/tests/baselines/reference/reactNamespaceInvalidInput.js +++ b/tests/baselines/reference/reactNamespaceInvalidInput.js @@ -1,5 +1,4 @@ //// [reactNamespaceInvalidInput.tsx] - ; diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.js b/tests/baselines/reference/reactNamespaceJSXEmit.js index 3a21504bb80..fc30f7f7bfa 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.js +++ b/tests/baselines/reference/reactNamespaceJSXEmit.js @@ -1,5 +1,4 @@ //// [reactNamespaceJSXEmit.tsx] - declare var myReactLib: any; declare var foo: any; declare var Bar: any; diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.symbols b/tests/baselines/reference/reactNamespaceJSXEmit.symbols index 55aae09776c..b8e58fb1702 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.symbols +++ b/tests/baselines/reference/reactNamespaceJSXEmit.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/reactNamespaceJSXEmit.tsx === - declare var myReactLib: any; ->myReactLib : Symbol(myReactLib, Decl(reactNamespaceJSXEmit.tsx, 1, 11)) +>myReactLib : Symbol(myReactLib, Decl(reactNamespaceJSXEmit.tsx, 0, 11)) declare var foo: any; ->foo : Symbol(foo, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>foo : Symbol(foo, Decl(reactNamespaceJSXEmit.tsx, 1, 11)) declare var Bar: any; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) declare var x: any; ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ; >foo : Symbol(unknown) ->data : Symbol(data, Decl(reactNamespaceJSXEmit.tsx, 6, 4)) +>data : Symbol(data, Decl(reactNamespaceJSXEmit.tsx, 5, 4)) ; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 7, 4)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 6, 4)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ; >x-component : Symbol(unknown) ; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) ->y : Symbol(y, Decl(reactNamespaceJSXEmit.tsx, 10, 13)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) +>y : Symbol(y, Decl(reactNamespaceJSXEmit.tsx, 9, 13)) diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.types b/tests/baselines/reference/reactNamespaceJSXEmit.types index 0f6fbd68309..0c1200b362b 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.types +++ b/tests/baselines/reference/reactNamespaceJSXEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/reactNamespaceJSXEmit.tsx === - declare var myReactLib: any; >myReactLib : any diff --git a/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt b/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt index f87d223f824..2b5194cc8ab 100644 --- a/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt +++ b/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/reactNamespaceMissingDeclaration.tsx(3,2): error TS2304: Cannot find name 'myReactLib'. +tests/cases/compiler/reactNamespaceMissingDeclaration.tsx(2,2): error TS2304: Cannot find name 'myReactLib'. ==== tests/cases/compiler/reactNamespaceMissingDeclaration.tsx (1 errors) ==== - // Error myReactLib not declared ~~~ diff --git a/tests/baselines/reference/reactNamespaceMissingDeclaration.js b/tests/baselines/reference/reactNamespaceMissingDeclaration.js index 8faeffa6496..784174ac728 100644 --- a/tests/baselines/reference/reactNamespaceMissingDeclaration.js +++ b/tests/baselines/reference/reactNamespaceMissingDeclaration.js @@ -1,5 +1,4 @@ //// [reactNamespaceMissingDeclaration.tsx] - // Error myReactLib not declared diff --git a/tests/baselines/reference/readonlyInDeclarationFile.js b/tests/baselines/reference/readonlyInDeclarationFile.js index 71e48272ecc..598c433d81f 100644 --- a/tests/baselines/reference/readonlyInDeclarationFile.js +++ b/tests/baselines/reference/readonlyInDeclarationFile.js @@ -1,5 +1,4 @@ //// [readonlyInDeclarationFile.ts] - interface Foo { readonly x: number; readonly [x: string]: Object; diff --git a/tests/baselines/reference/readonlyInDeclarationFile.symbols b/tests/baselines/reference/readonlyInDeclarationFile.symbols index c5f3b066a5d..9ec0e7f5e78 100644 --- a/tests/baselines/reference/readonlyInDeclarationFile.symbols +++ b/tests/baselines/reference/readonlyInDeclarationFile.symbols @@ -1,142 +1,141 @@ === tests/cases/compiler/readonlyInDeclarationFile.ts === - interface Foo { >Foo : Symbol(Foo, Decl(readonlyInDeclarationFile.ts, 0, 0)) readonly x: number; ->x : Symbol(Foo.x, Decl(readonlyInDeclarationFile.ts, 1, 15)) +>x : Symbol(Foo.x, Decl(readonlyInDeclarationFile.ts, 0, 15)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 3, 14)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 2, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } class C { ->C : Symbol(C, Decl(readonlyInDeclarationFile.ts, 4, 1)) +>C : Symbol(C, Decl(readonlyInDeclarationFile.ts, 3, 1)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 7, 14)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 6, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) private readonly a1: number; ->a1 : Symbol(C.a1, Decl(readonlyInDeclarationFile.ts, 7, 33)) +>a1 : Symbol(C.a1, Decl(readonlyInDeclarationFile.ts, 6, 33)) protected readonly a2: number; ->a2 : Symbol(C.a2, Decl(readonlyInDeclarationFile.ts, 8, 32)) +>a2 : Symbol(C.a2, Decl(readonlyInDeclarationFile.ts, 7, 32)) public readonly a3: number; ->a3 : Symbol(C.a3, Decl(readonlyInDeclarationFile.ts, 9, 34)) +>a3 : Symbol(C.a3, Decl(readonlyInDeclarationFile.ts, 8, 34)) private get b1() { return 1 } ->b1 : Symbol(C.b1, Decl(readonlyInDeclarationFile.ts, 10, 31)) +>b1 : Symbol(C.b1, Decl(readonlyInDeclarationFile.ts, 9, 31)) protected get b2() { return 1 } ->b2 : Symbol(C.b2, Decl(readonlyInDeclarationFile.ts, 11, 33)) +>b2 : Symbol(C.b2, Decl(readonlyInDeclarationFile.ts, 10, 33)) public get b3() { return 1 } ->b3 : Symbol(C.b3, Decl(readonlyInDeclarationFile.ts, 12, 35)) +>b3 : Symbol(C.b3, Decl(readonlyInDeclarationFile.ts, 11, 35)) private get c1() { return 1 } ->c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 13, 32), Decl(readonlyInDeclarationFile.ts, 14, 33)) +>c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 12, 32), Decl(readonlyInDeclarationFile.ts, 13, 33)) private set c1(value) { } ->c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 13, 32), Decl(readonlyInDeclarationFile.ts, 14, 33)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 15, 19)) +>c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 12, 32), Decl(readonlyInDeclarationFile.ts, 13, 33)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 14, 19)) protected get c2() { return 1 } ->c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 15, 29), Decl(readonlyInDeclarationFile.ts, 16, 35)) +>c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 14, 29), Decl(readonlyInDeclarationFile.ts, 15, 35)) protected set c2(value) { } ->c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 15, 29), Decl(readonlyInDeclarationFile.ts, 16, 35)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 17, 21)) +>c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 14, 29), Decl(readonlyInDeclarationFile.ts, 15, 35)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 16, 21)) public get c3() { return 1 } ->c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 17, 31), Decl(readonlyInDeclarationFile.ts, 18, 32)) +>c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 16, 31), Decl(readonlyInDeclarationFile.ts, 17, 32)) public set c3(value) { } ->c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 17, 31), Decl(readonlyInDeclarationFile.ts, 18, 32)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 19, 18)) +>c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 16, 31), Decl(readonlyInDeclarationFile.ts, 17, 32)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 18, 18)) private static readonly s1: number; ->s1 : Symbol(C.s1, Decl(readonlyInDeclarationFile.ts, 19, 28)) +>s1 : Symbol(C.s1, Decl(readonlyInDeclarationFile.ts, 18, 28)) protected static readonly s2: number; ->s2 : Symbol(C.s2, Decl(readonlyInDeclarationFile.ts, 20, 39)) +>s2 : Symbol(C.s2, Decl(readonlyInDeclarationFile.ts, 19, 39)) public static readonly s3: number; ->s3 : Symbol(C.s3, Decl(readonlyInDeclarationFile.ts, 21, 41)) +>s3 : Symbol(C.s3, Decl(readonlyInDeclarationFile.ts, 20, 41)) private static get t1() { return 1 } ->t1 : Symbol(C.t1, Decl(readonlyInDeclarationFile.ts, 22, 38)) +>t1 : Symbol(C.t1, Decl(readonlyInDeclarationFile.ts, 21, 38)) protected static get t2() { return 1 } ->t2 : Symbol(C.t2, Decl(readonlyInDeclarationFile.ts, 23, 40)) +>t2 : Symbol(C.t2, Decl(readonlyInDeclarationFile.ts, 22, 40)) public static get t3() { return 1 } ->t3 : Symbol(C.t3, Decl(readonlyInDeclarationFile.ts, 24, 42)) +>t3 : Symbol(C.t3, Decl(readonlyInDeclarationFile.ts, 23, 42)) private static get u1() { return 1 } ->u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 25, 39), Decl(readonlyInDeclarationFile.ts, 26, 40)) +>u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 24, 39), Decl(readonlyInDeclarationFile.ts, 25, 40)) private static set u1(value) { } ->u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 25, 39), Decl(readonlyInDeclarationFile.ts, 26, 40)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 27, 26)) +>u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 24, 39), Decl(readonlyInDeclarationFile.ts, 25, 40)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 26, 26)) protected static get u2() { return 1 } ->u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 27, 36), Decl(readonlyInDeclarationFile.ts, 28, 42)) +>u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 26, 36), Decl(readonlyInDeclarationFile.ts, 27, 42)) protected static set u2(value) { } ->u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 27, 36), Decl(readonlyInDeclarationFile.ts, 28, 42)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 29, 28)) +>u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 26, 36), Decl(readonlyInDeclarationFile.ts, 27, 42)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 28, 28)) public static get u3() { return 1 } ->u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 29, 38), Decl(readonlyInDeclarationFile.ts, 30, 39)) +>u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 28, 38), Decl(readonlyInDeclarationFile.ts, 29, 39)) public static set u3(value) { } ->u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 29, 38), Decl(readonlyInDeclarationFile.ts, 30, 39)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 31, 25)) +>u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 28, 38), Decl(readonlyInDeclarationFile.ts, 29, 39)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 30, 25)) } var z: { ->z : Symbol(z, Decl(readonlyInDeclarationFile.ts, 34, 3)) +>z : Symbol(z, Decl(readonlyInDeclarationFile.ts, 33, 3)) readonly a: string; ->a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 34, 8)) +>a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 33, 8)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 36, 14)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 35, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f() { ->f : Symbol(f, Decl(readonlyInDeclarationFile.ts, 37, 1)) +>f : Symbol(f, Decl(readonlyInDeclarationFile.ts, 36, 1)) return { get x() { return 1; }, ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 40, 12)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 39, 12)) get y() { return 1; }, ->y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 41, 30), Decl(readonlyInDeclarationFile.ts, 42, 30)) +>y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 40, 30), Decl(readonlyInDeclarationFile.ts, 41, 30)) set y(value) { } ->y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 41, 30), Decl(readonlyInDeclarationFile.ts, 42, 30)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 43, 14)) +>y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 40, 30), Decl(readonlyInDeclarationFile.ts, 41, 30)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 42, 14)) } } function g() { ->g : Symbol(g, Decl(readonlyInDeclarationFile.ts, 45, 1)) +>g : Symbol(g, Decl(readonlyInDeclarationFile.ts, 44, 1)) var x: { ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 48, 7)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 47, 7)) readonly a: string; ->a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 48, 12)) +>a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 47, 12)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 50, 18)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 49, 18)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } return x; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 48, 7)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 47, 7)) } diff --git a/tests/baselines/reference/readonlyInDeclarationFile.types b/tests/baselines/reference/readonlyInDeclarationFile.types index ca83a0a4c01..668188a9c42 100644 --- a/tests/baselines/reference/readonlyInDeclarationFile.types +++ b/tests/baselines/reference/readonlyInDeclarationFile.types @@ -1,5 +1,4 @@ === tests/cases/compiler/readonlyInDeclarationFile.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt b/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt index 9e759cb8343..3522a2e50fc 100644 --- a/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt +++ b/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/readonlyInNonPropertyParameters.ts(4,9): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/readonlyInNonPropertyParameters.ts(5,8): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/readonlyInNonPropertyParameters.ts(7,2): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/readonlyInNonPropertyParameters.ts(3,9): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/readonlyInNonPropertyParameters.ts(4,8): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/readonlyInNonPropertyParameters.ts(6,2): error TS2369: A parameter property is only allowed in a constructor implementation. ==== tests/cases/compiler/readonlyInNonPropertyParameters.ts (3 errors) ==== - // `readonly` won't work outside of property parameters class X { method(readonly x: number) {} diff --git a/tests/baselines/reference/readonlyInNonPropertyParameters.js b/tests/baselines/reference/readonlyInNonPropertyParameters.js index db58f73d2ff..658cf1331cd 100644 --- a/tests/baselines/reference/readonlyInNonPropertyParameters.js +++ b/tests/baselines/reference/readonlyInNonPropertyParameters.js @@ -1,5 +1,4 @@ //// [readonlyInNonPropertyParameters.ts] - // `readonly` won't work outside of property parameters class X { method(readonly x: number) {} diff --git a/tests/baselines/reference/readonlyMembers.errors.txt b/tests/baselines/reference/readonlyMembers.errors.txt index 7a6b74359d1..9baf37f27e7 100644 --- a/tests/baselines/reference/readonlyMembers.errors.txt +++ b/tests/baselines/reference/readonlyMembers.errors.txt @@ -1,22 +1,21 @@ -tests/cases/compiler/readonlyMembers.ts(7,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(8,3): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(17,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(19,18): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(20,18): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(21,18): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(25,14): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(26,14): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(27,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(36,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(40,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(49,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(56,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(62,1): error TS2542: Index signature in type '{ readonly [x: string]: string; }' only permits reading. -tests/cases/compiler/readonlyMembers.ts(65,1): error TS2542: Index signature in type '{ [x: string]: string; readonly [x: number]: string; }' only permits reading. +tests/cases/compiler/readonlyMembers.ts(6,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(7,3): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(16,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(18,18): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(19,18): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(20,18): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(24,14): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(25,14): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(26,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(35,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(39,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(48,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(55,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(61,1): error TS2542: Index signature in type '{ readonly [x: string]: string; }' only permits reading. +tests/cases/compiler/readonlyMembers.ts(64,1): error TS2542: Index signature in type '{ [x: string]: string; readonly [x: number]: string; }' only permits reading. ==== tests/cases/compiler/readonlyMembers.ts (15 errors) ==== - interface X { readonly a: number; readonly b?: number; diff --git a/tests/baselines/reference/readonlyMembers.js b/tests/baselines/reference/readonlyMembers.js index 899c52d8626..7ba4b992f78 100644 --- a/tests/baselines/reference/readonlyMembers.js +++ b/tests/baselines/reference/readonlyMembers.js @@ -1,5 +1,4 @@ //// [readonlyMembers.ts] - interface X { readonly a: number; readonly b?: number; diff --git a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js index b3ef0cba312..4922b59f5b3 100644 --- a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js +++ b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js @@ -1,5 +1,4 @@ //// [recurringTypeParamForContainerOfBase01.ts] - interface BoxOfFoo> { item: T } diff --git a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols index 48ea1ffa0cf..2c55e217fc2 100644 --- a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols +++ b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols @@ -1,37 +1,36 @@ === tests/cases/conformance/types/typeParameters/recurringTypeParamForContainerOfBase01.ts === - interface BoxOfFoo> { >BoxOfFoo : Symbol(BoxOfFoo, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 0)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 19)) ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 19)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 19)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 19)) item: T ->item : Symbol(BoxOfFoo.item, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 38)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 19)) +>item : Symbol(BoxOfFoo.item, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 38)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 19)) } interface Foo> { ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 14)) ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 14)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 14)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 14)) self: T; ->self : Symbol(Foo.self, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 33)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 14)) +>self : Symbol(Foo.self, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 33)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 14)) } interface Bar> extends Foo { ->Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 7, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) ->Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 7, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) +>Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 6, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) +>Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 6, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) other: BoxOfFoo; ->other : Symbol(Bar.other, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 48)) +>other : Symbol(Bar.other, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 48)) >BoxOfFoo : Symbol(BoxOfFoo, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 0)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) } diff --git a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types index 38b23263f01..432fccfc552 100644 --- a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types +++ b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeParameters/recurringTypeParamForContainerOfBase01.ts === - interface BoxOfFoo> { >BoxOfFoo : BoxOfFoo >T : T diff --git a/tests/baselines/reference/recursiveIdenticalOverloadResolution.js b/tests/baselines/reference/recursiveIdenticalOverloadResolution.js index 3c53c2b2a0a..772b561e9a6 100644 --- a/tests/baselines/reference/recursiveIdenticalOverloadResolution.js +++ b/tests/baselines/reference/recursiveIdenticalOverloadResolution.js @@ -1,5 +1,4 @@ //// [recursiveIdenticalOverloadResolution.ts] - module M { interface I { (i: I): I; } diff --git a/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols b/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols index a759f07eda1..3b89b9ed7e7 100644 --- a/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols +++ b/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/recursiveIdenticalOverloadResolution.ts === - module M { >M : Symbol(M, Decl(recursiveIdenticalOverloadResolution.ts, 0, 0)) interface I { (i: I): I; } ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 3, 18)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 2, 18)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) function f(p: I) { return f }; ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->p : Symbol(p, Decl(recursiveIdenticalOverloadResolution.ts, 5, 14)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>p : Symbol(p, Decl(recursiveIdenticalOverloadResolution.ts, 4, 14)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) var i: I; ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) f(i); ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) f(f(i)); ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) f((f(f(i)))); ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) } diff --git a/tests/baselines/reference/recursiveIdenticalOverloadResolution.types b/tests/baselines/reference/recursiveIdenticalOverloadResolution.types index e2ec96b1c82..6308fceee37 100644 --- a/tests/baselines/reference/recursiveIdenticalOverloadResolution.types +++ b/tests/baselines/reference/recursiveIdenticalOverloadResolution.types @@ -1,5 +1,4 @@ === tests/cases/compiler/recursiveIdenticalOverloadResolution.ts === - module M { >M : typeof M diff --git a/tests/baselines/reference/recursiveInheritance.errors.txt b/tests/baselines/reference/recursiveInheritance.errors.txt index c724afc5a0e..2758d08a297 100644 --- a/tests/baselines/reference/recursiveInheritance.errors.txt +++ b/tests/baselines/reference/recursiveInheritance.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/recursiveInheritance.ts(2,11): error TS2310: Type 'I5' recursively references itself as a base type. -tests/cases/compiler/recursiveInheritance.ts(6,11): error TS2310: Type 'i8' recursively references itself as a base type. +tests/cases/compiler/recursiveInheritance.ts(1,11): error TS2310: Type 'I5' recursively references itself as a base type. +tests/cases/compiler/recursiveInheritance.ts(5,11): error TS2310: Type 'i8' recursively references itself as a base type. ==== tests/cases/compiler/recursiveInheritance.ts (2 errors) ==== - interface I5 extends I5 { // error ~~ !!! error TS2310: Type 'I5' recursively references itself as a base type. diff --git a/tests/baselines/reference/recursiveInheritance.js b/tests/baselines/reference/recursiveInheritance.js index 820bee28bcd..10153cbd1cb 100644 --- a/tests/baselines/reference/recursiveInheritance.js +++ b/tests/baselines/reference/recursiveInheritance.js @@ -1,5 +1,4 @@ //// [recursiveInheritance.ts] - interface I5 extends I5 { // error foo():void; } diff --git a/tests/baselines/reference/recursiveMappedTypes.errors.txt b/tests/baselines/reference/recursiveMappedTypes.errors.txt index 3dd6a55cf8c..440825f5319 100644 --- a/tests/baselines/reference/recursiveMappedTypes.errors.txt +++ b/tests/baselines/reference/recursiveMappedTypes.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(4,6): error TS2456: Type alias 'Recurse' circularly references itself. -tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(8,6): error TS2456: Type alias 'Recurse1' circularly references itself. -tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,6): error TS2456: Type alias 'Recurse2' circularly references itself. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(3,6): error TS2456: Type alias 'Recurse' circularly references itself. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(7,6): error TS2456: Type alias 'Recurse1' circularly references itself. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(11,6): error TS2456: Type alias 'Recurse2' circularly references itself. ==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (3 errors) ==== - // Recursive mapped types simply appear empty type Recurse = { diff --git a/tests/baselines/reference/recursiveMappedTypes.js b/tests/baselines/reference/recursiveMappedTypes.js index dfe69457ed7..50610708664 100644 --- a/tests/baselines/reference/recursiveMappedTypes.js +++ b/tests/baselines/reference/recursiveMappedTypes.js @@ -1,5 +1,4 @@ //// [recursiveMappedTypes.ts] - // Recursive mapped types simply appear empty type Recurse = { diff --git a/tests/baselines/reference/recursiveMods.js b/tests/baselines/reference/recursiveMods.js index 3c41bed5e62..f9f48a4a891 100644 --- a/tests/baselines/reference/recursiveMods.js +++ b/tests/baselines/reference/recursiveMods.js @@ -1,5 +1,4 @@ //// [recursiveMods.ts] - export module Foo { export class C {} } diff --git a/tests/baselines/reference/recursiveMods.symbols b/tests/baselines/reference/recursiveMods.symbols index 5f6d6f87721..1e7e8fa1c84 100644 --- a/tests/baselines/reference/recursiveMods.symbols +++ b/tests/baselines/reference/recursiveMods.symbols @@ -1,45 +1,44 @@ === tests/cases/compiler/recursiveMods.ts === - export module Foo { ->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1)) +>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1)) export class C {} ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) } export module Foo { ->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1)) +>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1)) function Bar() : C { ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) if (true) { return Bar();} ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) return new C(); ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) } function Baz() : C { ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) var c = Baz(); ->c : Symbol(c, Decl(recursiveMods.ts, 13, 5)) ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) +>c : Symbol(c, Decl(recursiveMods.ts, 12, 5)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) return Bar(); ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) } function Gar() { ->Gar : Symbol(Gar, Decl(recursiveMods.ts, 15, 2)) +>Gar : Symbol(Gar, Decl(recursiveMods.ts, 14, 2)) var c : C = Baz(); ->c : Symbol(c, Decl(recursiveMods.ts, 18, 5)) ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) +>c : Symbol(c, Decl(recursiveMods.ts, 17, 5)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) return; } diff --git a/tests/baselines/reference/recursiveMods.types b/tests/baselines/reference/recursiveMods.types index 45e803fee1e..8ffd41838c0 100644 --- a/tests/baselines/reference/recursiveMods.types +++ b/tests/baselines/reference/recursiveMods.types @@ -1,5 +1,4 @@ === tests/cases/compiler/recursiveMods.ts === - export module Foo { >Foo : typeof Foo diff --git a/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt b/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt index 9b1cad852ab..c101e131c7d 100644 --- a/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt +++ b/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/redeclareParameterInCatchBlock.ts(5,11): error TS2492: Cannot redeclare identifier 'e' in catch clause. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(11,9): error TS2492: Cannot redeclare identifier 'e' in catch clause. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(17,15): error TS2492: Cannot redeclare identifier 'b' in catch clause. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(22,15): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(22,21): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(4,11): error TS2492: Cannot redeclare identifier 'e' in catch clause. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(10,9): error TS2492: Cannot redeclare identifier 'e' in catch clause. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(16,15): error TS2492: Cannot redeclare identifier 'b' in catch clause. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(21,15): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(21,21): error TS2451: Cannot redeclare block-scoped variable 'x'. ==== tests/cases/compiler/redeclareParameterInCatchBlock.ts (5 errors) ==== - try { } catch(e) { diff --git a/tests/baselines/reference/redeclareParameterInCatchBlock.js b/tests/baselines/reference/redeclareParameterInCatchBlock.js index 9fafe0b17be..8ccfb16142b 100644 --- a/tests/baselines/reference/redeclareParameterInCatchBlock.js +++ b/tests/baselines/reference/redeclareParameterInCatchBlock.js @@ -1,5 +1,4 @@ //// [redeclareParameterInCatchBlock.ts] - try { } catch(e) { diff --git a/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt b/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt index 65a42775331..228c395cf11 100644 --- a/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt +++ b/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/somefolder/a.ts(2,17): error TS2307: Cannot find module './b'. +tests/cases/compiler/somefolder/a.ts(1,17): error TS2307: Cannot find module './b'. ==== tests/cases/compiler/somefolder/a.ts (1 errors) ==== - import {x} from "./b" ~~~~~ !!! error TS2307: Cannot find module './b'. diff --git a/tests/baselines/reference/relativeNamesInClassicResolution.js b/tests/baselines/reference/relativeNamesInClassicResolution.js index cf43ec2a5ca..cb7616243ef 100644 --- a/tests/baselines/reference/relativeNamesInClassicResolution.js +++ b/tests/baselines/reference/relativeNamesInClassicResolution.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/relativeNamesInClassicResolution.ts] //// //// [a.ts] - import {x} from "./b" //// [b.ts] diff --git a/tests/baselines/reference/restUnion2.js b/tests/baselines/reference/restUnion2.js index 44a0acfbcf8..71f4b06cfef 100644 --- a/tests/baselines/reference/restUnion2.js +++ b/tests/baselines/reference/restUnion2.js @@ -1,5 +1,4 @@ //// [restUnion2.ts] - declare const undefinedUnion: { n: number } | undefined; var rest2: { n: number }; var {...rest2 } = undefinedUnion; diff --git a/tests/baselines/reference/restUnion2.symbols b/tests/baselines/reference/restUnion2.symbols index 20a113a23b4..54ac47f0694 100644 --- a/tests/baselines/reference/restUnion2.symbols +++ b/tests/baselines/reference/restUnion2.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/restUnion2.ts === - declare const undefinedUnion: { n: number } | undefined; ->undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 1, 13)) ->n : Symbol(n, Decl(restUnion2.ts, 1, 31)) +>undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 0, 13)) +>n : Symbol(n, Decl(restUnion2.ts, 0, 31)) var rest2: { n: number }; ->rest2 : Symbol(rest2, Decl(restUnion2.ts, 2, 3), Decl(restUnion2.ts, 3, 5)) ->n : Symbol(n, Decl(restUnion2.ts, 2, 12)) +>rest2 : Symbol(rest2, Decl(restUnion2.ts, 1, 3), Decl(restUnion2.ts, 2, 5)) +>n : Symbol(n, Decl(restUnion2.ts, 1, 12)) var {...rest2 } = undefinedUnion; ->rest2 : Symbol(rest2, Decl(restUnion2.ts, 2, 3), Decl(restUnion2.ts, 3, 5)) ->undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 1, 13)) +>rest2 : Symbol(rest2, Decl(restUnion2.ts, 1, 3), Decl(restUnion2.ts, 2, 5)) +>undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 0, 13)) declare const nullUnion: { n: number } | null; ->nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 6, 13)) ->n : Symbol(n, Decl(restUnion2.ts, 6, 26)) +>nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 5, 13)) +>n : Symbol(n, Decl(restUnion2.ts, 5, 26)) var rest3: { n: number }; ->rest3 : Symbol(rest3, Decl(restUnion2.ts, 7, 3), Decl(restUnion2.ts, 8, 5)) ->n : Symbol(n, Decl(restUnion2.ts, 7, 12)) +>rest3 : Symbol(rest3, Decl(restUnion2.ts, 6, 3), Decl(restUnion2.ts, 7, 5)) +>n : Symbol(n, Decl(restUnion2.ts, 6, 12)) var {...rest3 } = nullUnion; ->rest3 : Symbol(rest3, Decl(restUnion2.ts, 7, 3), Decl(restUnion2.ts, 8, 5)) ->nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 6, 13)) +>rest3 : Symbol(rest3, Decl(restUnion2.ts, 6, 3), Decl(restUnion2.ts, 7, 5)) +>nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 5, 13)) declare const nullAndUndefinedUnion: null | undefined; ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 11, 13)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 10, 13)) var rest4: { }; ->rest4 : Symbol(rest4, Decl(restUnion2.ts, 12, 3), Decl(restUnion2.ts, 13, 5)) +>rest4 : Symbol(rest4, Decl(restUnion2.ts, 11, 3), Decl(restUnion2.ts, 12, 5)) var {...rest4 } = nullAndUndefinedUnion; ->rest4 : Symbol(rest4, Decl(restUnion2.ts, 12, 3), Decl(restUnion2.ts, 13, 5)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 11, 13)) +>rest4 : Symbol(rest4, Decl(restUnion2.ts, 11, 3), Decl(restUnion2.ts, 12, 5)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 10, 13)) declare const unionWithIntersection: ({ n: number } & { s: string }) & undefined | null; ->unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 15, 13)) ->n : Symbol(n, Decl(restUnion2.ts, 15, 39)) ->s : Symbol(s, Decl(restUnion2.ts, 15, 55)) +>unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 14, 13)) +>n : Symbol(n, Decl(restUnion2.ts, 14, 39)) +>s : Symbol(s, Decl(restUnion2.ts, 14, 55)) var rest5: { n: number, s: string }; ->rest5 : Symbol(rest5, Decl(restUnion2.ts, 16, 3), Decl(restUnion2.ts, 17, 5)) ->n : Symbol(n, Decl(restUnion2.ts, 16, 12)) ->s : Symbol(s, Decl(restUnion2.ts, 16, 23)) +>rest5 : Symbol(rest5, Decl(restUnion2.ts, 15, 3), Decl(restUnion2.ts, 16, 5)) +>n : Symbol(n, Decl(restUnion2.ts, 15, 12)) +>s : Symbol(s, Decl(restUnion2.ts, 15, 23)) var {...rest5 } = unionWithIntersection; ->rest5 : Symbol(rest5, Decl(restUnion2.ts, 16, 3), Decl(restUnion2.ts, 17, 5)) ->unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 15, 13)) +>rest5 : Symbol(rest5, Decl(restUnion2.ts, 15, 3), Decl(restUnion2.ts, 16, 5)) +>unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 14, 13)) diff --git a/tests/baselines/reference/restUnion2.types b/tests/baselines/reference/restUnion2.types index 81b768777fd..03c8d577e66 100644 --- a/tests/baselines/reference/restUnion2.types +++ b/tests/baselines/reference/restUnion2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/restUnion2.ts === - declare const undefinedUnion: { n: number } | undefined; >undefinedUnion : { n: number; } | undefined >n : number diff --git a/tests/baselines/reference/returnStatement1.js b/tests/baselines/reference/returnStatement1.js index 3f5c5561b2a..c4ccc3cadde 100644 --- a/tests/baselines/reference/returnStatement1.js +++ b/tests/baselines/reference/returnStatement1.js @@ -1,5 +1,4 @@ //// [returnStatement1.ts] - function f() { return function (s) { var x = s; diff --git a/tests/baselines/reference/returnStatement1.symbols b/tests/baselines/reference/returnStatement1.symbols index 6727cba0df5..acec9f76003 100644 --- a/tests/baselines/reference/returnStatement1.symbols +++ b/tests/baselines/reference/returnStatement1.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/returnStatement1.ts === - function f() { >f : Symbol(f, Decl(returnStatement1.ts, 0, 0)) return function (s) { ->s : Symbol(s, Decl(returnStatement1.ts, 2, 21)) +>s : Symbol(s, Decl(returnStatement1.ts, 1, 21)) var x = s; ->x : Symbol(x, Decl(returnStatement1.ts, 3, 11)) ->s : Symbol(s, Decl(returnStatement1.ts, 2, 21)) +>x : Symbol(x, Decl(returnStatement1.ts, 2, 11)) +>s : Symbol(s, Decl(returnStatement1.ts, 1, 21)) }; ("harmless extra line"); diff --git a/tests/baselines/reference/returnStatement1.types b/tests/baselines/reference/returnStatement1.types index 0c909551043..61a2c67f828 100644 --- a/tests/baselines/reference/returnStatement1.types +++ b/tests/baselines/reference/returnStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/returnStatement1.ts === - function f() { >f : () => (s: any) => void diff --git a/tests/baselines/reference/scannerClass2.errors.txt b/tests/baselines/reference/scannerClass2.errors.txt index e7a1765a766..6509d05aa72 100644 --- a/tests/baselines/reference/scannerClass2.errors.txt +++ b/tests/baselines/reference/scannerClass2.errors.txt @@ -1,11 +1,9 @@ -tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(3,43): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(4,37): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(5,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. +tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(1,43): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(2,37): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(3,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. ==== tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts (3 errors) ==== - - export class LoggerAdapter implements ILogger { ~~~~~~~ !!! error TS2304: Cannot find name 'ILogger'. diff --git a/tests/baselines/reference/scannerClass2.js b/tests/baselines/reference/scannerClass2.js index bc489268afd..339098b481a 100644 --- a/tests/baselines/reference/scannerClass2.js +++ b/tests/baselines/reference/scannerClass2.js @@ -1,6 +1,4 @@ //// [scannerClass2.ts] - - export class LoggerAdapter implements ILogger { constructor (public logger: ILogger) { this._information = this.logger.information(); diff --git a/tests/baselines/reference/shebangBeforeReferences.js b/tests/baselines/reference/shebangBeforeReferences.js index 41f3cee97e1..4ebf692e1d5 100644 --- a/tests/baselines/reference/shebangBeforeReferences.js +++ b/tests/baselines/reference/shebangBeforeReferences.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/shebangBeforeReferences.ts] //// //// [f.d.ts] - declare module "test" { let x: number; } diff --git a/tests/baselines/reference/shebangBeforeReferences.symbols b/tests/baselines/reference/shebangBeforeReferences.symbols index 23bfe58fc62..03e20113f58 100644 --- a/tests/baselines/reference/shebangBeforeReferences.symbols +++ b/tests/baselines/reference/shebangBeforeReferences.symbols @@ -15,9 +15,8 @@ use(x); >x : Symbol(x, Decl(f.ts, 5, 8)) === tests/cases/compiler/f.d.ts === - declare module "test" { let x: number; ->x : Symbol(x, Decl(f.d.ts, 2, 7)) +>x : Symbol(x, Decl(f.d.ts, 1, 7)) } diff --git a/tests/baselines/reference/shebangBeforeReferences.types b/tests/baselines/reference/shebangBeforeReferences.types index 89b63a1a0b4..8b594d76509 100644 --- a/tests/baselines/reference/shebangBeforeReferences.types +++ b/tests/baselines/reference/shebangBeforeReferences.types @@ -16,7 +16,6 @@ use(x); >x : number === tests/cases/compiler/f.d.ts === - declare module "test" { let x: number; >x : number diff --git a/tests/baselines/reference/shorthand-property-es5-es6.errors.txt b/tests/baselines/reference/shorthand-property-es5-es6.errors.txt index e54f73a4e61..650263a08c4 100644 --- a/tests/baselines/reference/shorthand-property-es5-es6.errors.txt +++ b/tests/baselines/reference/shorthand-property-es5-es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './foo'. +tests/cases/compiler/test.ts(1,19): error TS2307: Cannot find module './foo'. ==== tests/cases/compiler/test.ts (1 errors) ==== - import {foo} from './foo'; ~~~~~~~ !!! error TS2307: Cannot find module './foo'. diff --git a/tests/baselines/reference/shorthand-property-es5-es6.js b/tests/baselines/reference/shorthand-property-es5-es6.js index cbca92adb0c..671ce39795c 100644 --- a/tests/baselines/reference/shorthand-property-es5-es6.js +++ b/tests/baselines/reference/shorthand-property-es5-es6.js @@ -1,5 +1,4 @@ //// [test.ts] - import {foo} from './foo'; const baz = 42; const bar = { foo, baz }; diff --git a/tests/baselines/reference/shorthand-property-es6-amd.errors.txt b/tests/baselines/reference/shorthand-property-es6-amd.errors.txt index e54f73a4e61..650263a08c4 100644 --- a/tests/baselines/reference/shorthand-property-es6-amd.errors.txt +++ b/tests/baselines/reference/shorthand-property-es6-amd.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './foo'. +tests/cases/compiler/test.ts(1,19): error TS2307: Cannot find module './foo'. ==== tests/cases/compiler/test.ts (1 errors) ==== - import {foo} from './foo'; ~~~~~~~ !!! error TS2307: Cannot find module './foo'. diff --git a/tests/baselines/reference/shorthand-property-es6-amd.js b/tests/baselines/reference/shorthand-property-es6-amd.js index 0935606ca5d..9469357eea2 100644 --- a/tests/baselines/reference/shorthand-property-es6-amd.js +++ b/tests/baselines/reference/shorthand-property-es6-amd.js @@ -1,5 +1,4 @@ //// [test.ts] - import {foo} from './foo'; const baz = 42; const bar = { foo, baz }; diff --git a/tests/baselines/reference/shorthand-property-es6-es6.errors.txt b/tests/baselines/reference/shorthand-property-es6-es6.errors.txt index e54f73a4e61..650263a08c4 100644 --- a/tests/baselines/reference/shorthand-property-es6-es6.errors.txt +++ b/tests/baselines/reference/shorthand-property-es6-es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './foo'. +tests/cases/compiler/test.ts(1,19): error TS2307: Cannot find module './foo'. ==== tests/cases/compiler/test.ts (1 errors) ==== - import {foo} from './foo'; ~~~~~~~ !!! error TS2307: Cannot find module './foo'. diff --git a/tests/baselines/reference/shorthand-property-es6-es6.js b/tests/baselines/reference/shorthand-property-es6-es6.js index eff67c879cc..42c80db10a0 100644 --- a/tests/baselines/reference/shorthand-property-es6-es6.js +++ b/tests/baselines/reference/shorthand-property-es6-es6.js @@ -1,5 +1,4 @@ //// [test.ts] - import {foo} from './foo'; const baz = 42; const bar = { foo, baz }; diff --git a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js index b61620c8eb5..86efc8d77d1 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js +++ b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js @@ -1,5 +1,4 @@ //// [shorthandOfExportedEntity01_targetES2015_CommonJS.ts] - export const test = "test"; export function foo () { diff --git a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols index 341d40bc542..83cd2dc75ca 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols +++ b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/shorthandOfExportedEntity01_targetES2015_CommonJS.ts === - export const test = "test"; ->test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 1, 12)) +>test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 0, 12)) export function foo () { ->foo : Symbol(foo, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 1, 27)) +>foo : Symbol(foo, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 0, 27)) const x = { test }; ->x : Symbol(x, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 4, 7)) ->test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 4, 13)) +>x : Symbol(x, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 3, 7)) +>test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 3, 13)) } diff --git a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types index f299632b3ef..2959acfeb64 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types +++ b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types @@ -1,5 +1,4 @@ === tests/cases/compiler/shorthandOfExportedEntity01_targetES2015_CommonJS.ts === - export const test = "test"; >test : "test" >"test" : "test" diff --git a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js index 9c63ca6aa28..29547215285 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js +++ b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js @@ -1,5 +1,4 @@ //// [shorthandOfExportedEntity02_targetES5_CommonJS.ts] - export const test = "test"; export function foo () { diff --git a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols index 3b0b40922c9..da42b1d991d 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols +++ b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/shorthandOfExportedEntity02_targetES5_CommonJS.ts === - export const test = "test"; ->test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 1, 12)) +>test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 0, 12)) export function foo () { ->foo : Symbol(foo, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 1, 27)) +>foo : Symbol(foo, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 0, 27)) const x = { test }; ->x : Symbol(x, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 4, 7)) ->test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 4, 13)) +>x : Symbol(x, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 3, 7)) +>test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 3, 13)) } diff --git a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types index effe8e89da4..146a32e14a5 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types +++ b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types @@ -1,5 +1,4 @@ === tests/cases/compiler/shorthandOfExportedEntity02_targetES5_CommonJS.ts === - export const test = "test"; >test : "test" >"test" : "test" diff --git a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt index 35fc45421c4..22522208ea8 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt +++ b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './missingM ==== tests/cases/compiler/existingModule.ts (0 errors) ==== - export var x = 1; ==== tests/cases/compiler/test.ts (1 errors) ==== diff --git a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js index f5c7a53f307..6da26a63f6b 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js +++ b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/shorthandPropertyAssignmentInES6Module.ts] //// //// [existingModule.ts] - export var x = 1; //// [test.ts] diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt index ce029a49f18..1225f9ab2ce 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt @@ -1,26 +1,24 @@ -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(40,9): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(46,12): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(72,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(77,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(14,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(20,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(38,9): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(44,12): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(70,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(75,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(75,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(80,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(80,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(85,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(85,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(85,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,12): error TS2304: Cannot find name 's'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(111,12): error TS2304: Cannot find name 's'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(111,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. ==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts (14 errors) ==== - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js index 6be02246e39..ca874652de8 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js @@ -1,6 +1,4 @@ //// [shorthandPropertyAssignmentsInDestructuring.ts] - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt index 0a61eed7326..acff36b6d1f 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt @@ -1,26 +1,24 @@ -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(40,9): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(46,12): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(72,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(77,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(14,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(20,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(38,9): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(44,12): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(70,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(75,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(75,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(80,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(80,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(85,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(85,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(85,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,12): error TS2304: Cannot find name 's'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(111,12): error TS2304: Cannot find name 's'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(111,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. ==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts (14 errors) ==== - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js index 11068708110..a7c5089165e 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js @@ -1,6 +1,4 @@ //// [shorthandPropertyAssignmentsInDestructuring_ES6.ts] - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/sourceMap-FileWithComments.js b/tests/baselines/reference/sourceMap-FileWithComments.js index dd2131889af..d2287d0bea2 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.js +++ b/tests/baselines/reference/sourceMap-FileWithComments.js @@ -1,5 +1,4 @@ //// [sourceMap-FileWithComments.ts] - // Interface interface IPoint { getDist(): number; diff --git a/tests/baselines/reference/sourceMap-FileWithComments.js.map b/tests/baselines/reference/sourceMap-FileWithComments.js.map index 11d0f52a18d..a85ce154f11 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.js.map +++ b/tests/baselines/reference/sourceMap-FileWithComments.js.map @@ -1,2 +1,2 @@ //// [sourceMap-FileWithComments.js.map] -{"version":3,"file":"sourceMap-FileWithComments.js","sourceRoot":"","sources":["sourceMap-FileWithComments.ts"],"names":[],"mappings":"AAMA,SAAS;AACT,IAAO,MAAM,CAwBZ;AAxBD,WAAO,MAAM;IAET,QAAQ;IACR;QACI,cAAc;QACd,eAAmB,CAAS,EAAS,CAAS;YAA3B,MAAC,GAAD,CAAC,CAAQ;YAAS,MAAC,GAAD,CAAC,CAAQ;QAAI,CAAC;QAEnD,kBAAkB;QAClB,uBAAO,GAAP,cAAY,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAItE,YAAC;IAAD,CAAC,AATD;IAOI,gBAAgB;IACT,YAAM,GAAG,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IARvB,YAAK,QASjB,CAAA;IAED,+BAA+B;IAC/B,IAAI,CAAC,GAAG,EAAE,CAAC;IAEX;IACA,CAAC;IADe,UAAG,MAClB,CAAA;IAED;;MAEE;IACF,IAAI,CAAC,GAAG,EAAE,CAAC;AACf,CAAC,EAxBM,MAAM,KAAN,MAAM,QAwBZ;AAED,qBAAqB;AACrB,IAAI,CAAC,GAAW,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvC,IAAI,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMap-FileWithComments.js","sourceRoot":"","sources":["sourceMap-FileWithComments.ts"],"names":[],"mappings":"AAKA,SAAS;AACT,IAAO,MAAM,CAwBZ;AAxBD,WAAO,MAAM;IAET,QAAQ;IACR;QACI,cAAc;QACd,eAAmB,CAAS,EAAS,CAAS;YAA3B,MAAC,GAAD,CAAC,CAAQ;YAAS,MAAC,GAAD,CAAC,CAAQ;QAAI,CAAC;QAEnD,kBAAkB;QAClB,uBAAO,GAAP,cAAY,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAItE,YAAC;IAAD,CAAC,AATD;IAOI,gBAAgB;IACT,YAAM,GAAG,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IARvB,YAAK,QASjB,CAAA;IAED,+BAA+B;IAC/B,IAAI,CAAC,GAAG,EAAE,CAAC;IAEX;IACA,CAAC;IADe,UAAG,MAClB,CAAA;IAED;;MAEE;IACF,IAAI,CAAC,GAAG,EAAE,CAAC;AACf,CAAC,EAxBM,MAAM,KAAN,MAAM,QAwBZ;AAED,qBAAqB;AACrB,IAAI,CAAC,GAAW,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvC,IAAI,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt b/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt index fc822f1cfe0..9e81aba718a 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt +++ b/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt @@ -12,16 +12,15 @@ sourceFile:sourceMap-FileWithComments.ts 1 > 2 >^^^^^^^^^ 3 > ^^^-> -1 > - >// Interface +1 >// Interface >interface IPoint { > getDist(): number; >} > > 2 >// Module -1 >Emitted(1, 1) Source(7, 1) + SourceIndex(0) -2 >Emitted(1, 10) Source(7, 10) + SourceIndex(0) +1 >Emitted(1, 1) Source(6, 1) + SourceIndex(0) +2 >Emitted(1, 10) Source(6, 10) + SourceIndex(0) --- >>>var Shapes; 1-> @@ -58,10 +57,10 @@ sourceFile:sourceMap-FileWithComments.ts > */ > var b = 10; > } -1->Emitted(2, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(8, 8) + SourceIndex(0) -3 >Emitted(2, 11) Source(8, 14) + SourceIndex(0) -4 >Emitted(2, 12) Source(32, 2) + SourceIndex(0) +1->Emitted(2, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(7, 8) + SourceIndex(0) +3 >Emitted(2, 11) Source(7, 14) + SourceIndex(0) +4 >Emitted(2, 12) Source(31, 2) + SourceIndex(0) --- >>>(function (Shapes) { 1-> @@ -70,9 +69,9 @@ sourceFile:sourceMap-FileWithComments.ts 1-> 2 >module 3 > Shapes -1->Emitted(3, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(3, 12) Source(8, 8) + SourceIndex(0) -3 >Emitted(3, 18) Source(8, 14) + SourceIndex(0) +1->Emitted(3, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(3, 12) Source(7, 8) + SourceIndex(0) +3 >Emitted(3, 18) Source(7, 14) + SourceIndex(0) --- >>> // Class 1 >^^^^ @@ -82,15 +81,15 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Class -1 >Emitted(4, 5) Source(10, 5) + SourceIndex(0) -2 >Emitted(4, 13) Source(10, 13) + SourceIndex(0) +1 >Emitted(4, 5) Source(9, 5) + SourceIndex(0) +2 >Emitted(4, 13) Source(9, 13) + SourceIndex(0) --- >>> var Point = (function () { 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> 1-> > -1->Emitted(5, 5) Source(11, 5) + SourceIndex(0) +1->Emitted(5, 5) Source(10, 5) + SourceIndex(0) --- >>> // Constructor 1->^^^^^^^^ @@ -99,8 +98,8 @@ sourceFile:sourceMap-FileWithComments.ts 1->export class Point implements IPoint { > 2 > // Constructor -1->Emitted(6, 9) Source(12, 9) + SourceIndex(0) -2 >Emitted(6, 23) Source(12, 23) + SourceIndex(0) +1->Emitted(6, 9) Source(11, 9) + SourceIndex(0) +2 >Emitted(6, 23) Source(11, 23) + SourceIndex(0) --- >>> function Point(x, y) { 1->^^^^^^^^ @@ -114,11 +113,11 @@ sourceFile:sourceMap-FileWithComments.ts 3 > x: number 4 > , public 5 > y: number -1->Emitted(7, 9) Source(13, 9) + SourceIndex(0) -2 >Emitted(7, 24) Source(13, 28) + SourceIndex(0) -3 >Emitted(7, 25) Source(13, 37) + SourceIndex(0) -4 >Emitted(7, 27) Source(13, 46) + SourceIndex(0) -5 >Emitted(7, 28) Source(13, 55) + SourceIndex(0) +1->Emitted(7, 9) Source(12, 9) + SourceIndex(0) +2 >Emitted(7, 24) Source(12, 28) + SourceIndex(0) +3 >Emitted(7, 25) Source(12, 37) + SourceIndex(0) +4 >Emitted(7, 27) Source(12, 46) + SourceIndex(0) +5 >Emitted(7, 28) Source(12, 55) + SourceIndex(0) --- >>> this.x = x; 1 >^^^^^^^^^^^^ @@ -132,11 +131,11 @@ sourceFile:sourceMap-FileWithComments.ts 3 > 4 > x 5 > : number -1 >Emitted(8, 13) Source(13, 28) + SourceIndex(0) -2 >Emitted(8, 19) Source(13, 29) + SourceIndex(0) -3 >Emitted(8, 22) Source(13, 28) + SourceIndex(0) -4 >Emitted(8, 23) Source(13, 29) + SourceIndex(0) -5 >Emitted(8, 24) Source(13, 37) + SourceIndex(0) +1 >Emitted(8, 13) Source(12, 28) + SourceIndex(0) +2 >Emitted(8, 19) Source(12, 29) + SourceIndex(0) +3 >Emitted(8, 22) Source(12, 28) + SourceIndex(0) +4 >Emitted(8, 23) Source(12, 29) + SourceIndex(0) +5 >Emitted(8, 24) Source(12, 37) + SourceIndex(0) --- >>> this.y = y; 1->^^^^^^^^^^^^ @@ -149,11 +148,11 @@ sourceFile:sourceMap-FileWithComments.ts 3 > 4 > y 5 > : number -1->Emitted(9, 13) Source(13, 46) + SourceIndex(0) -2 >Emitted(9, 19) Source(13, 47) + SourceIndex(0) -3 >Emitted(9, 22) Source(13, 46) + SourceIndex(0) -4 >Emitted(9, 23) Source(13, 47) + SourceIndex(0) -5 >Emitted(9, 24) Source(13, 55) + SourceIndex(0) +1->Emitted(9, 13) Source(12, 46) + SourceIndex(0) +2 >Emitted(9, 19) Source(12, 47) + SourceIndex(0) +3 >Emitted(9, 22) Source(12, 46) + SourceIndex(0) +4 >Emitted(9, 23) Source(12, 47) + SourceIndex(0) +5 >Emitted(9, 24) Source(12, 55) + SourceIndex(0) --- >>> } 1 >^^^^^^^^ @@ -161,8 +160,8 @@ sourceFile:sourceMap-FileWithComments.ts 3 > ^^^^^^^^^^^^^^^^^^-> 1 >) { 2 > } -1 >Emitted(10, 9) Source(13, 59) + SourceIndex(0) -2 >Emitted(10, 10) Source(13, 60) + SourceIndex(0) +1 >Emitted(10, 9) Source(12, 59) + SourceIndex(0) +2 >Emitted(10, 10) Source(12, 60) + SourceIndex(0) --- >>> // Instance member 1->^^^^^^^^ @@ -172,8 +171,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Instance member -1->Emitted(11, 9) Source(15, 9) + SourceIndex(0) -2 >Emitted(11, 27) Source(15, 27) + SourceIndex(0) +1->Emitted(11, 9) Source(14, 9) + SourceIndex(0) +2 >Emitted(11, 27) Source(14, 27) + SourceIndex(0) --- >>> Point.prototype.getDist = function () { return Math.sqrt(this.x * this.x + this.y * this.y); }; 1->^^^^^^^^ @@ -235,35 +234,35 @@ sourceFile:sourceMap-FileWithComments.ts 27> ; 28> 29> } -1->Emitted(12, 9) Source(16, 9) + SourceIndex(0) -2 >Emitted(12, 32) Source(16, 16) + SourceIndex(0) -3 >Emitted(12, 35) Source(16, 9) + SourceIndex(0) -4 >Emitted(12, 49) Source(16, 21) + SourceIndex(0) -5 >Emitted(12, 55) Source(16, 27) + SourceIndex(0) -6 >Emitted(12, 56) Source(16, 28) + SourceIndex(0) -7 >Emitted(12, 60) Source(16, 32) + SourceIndex(0) -8 >Emitted(12, 61) Source(16, 33) + SourceIndex(0) -9 >Emitted(12, 65) Source(16, 37) + SourceIndex(0) -10>Emitted(12, 66) Source(16, 38) + SourceIndex(0) -11>Emitted(12, 70) Source(16, 42) + SourceIndex(0) -12>Emitted(12, 71) Source(16, 43) + SourceIndex(0) -13>Emitted(12, 72) Source(16, 44) + SourceIndex(0) -14>Emitted(12, 75) Source(16, 47) + SourceIndex(0) -15>Emitted(12, 79) Source(16, 51) + SourceIndex(0) -16>Emitted(12, 80) Source(16, 52) + SourceIndex(0) -17>Emitted(12, 81) Source(16, 53) + SourceIndex(0) -18>Emitted(12, 84) Source(16, 56) + SourceIndex(0) -19>Emitted(12, 88) Source(16, 60) + SourceIndex(0) -20>Emitted(12, 89) Source(16, 61) + SourceIndex(0) -21>Emitted(12, 90) Source(16, 62) + SourceIndex(0) -22>Emitted(12, 93) Source(16, 65) + SourceIndex(0) -23>Emitted(12, 97) Source(16, 69) + SourceIndex(0) -24>Emitted(12, 98) Source(16, 70) + SourceIndex(0) -25>Emitted(12, 99) Source(16, 71) + SourceIndex(0) -26>Emitted(12, 100) Source(16, 72) + SourceIndex(0) -27>Emitted(12, 101) Source(16, 73) + SourceIndex(0) -28>Emitted(12, 102) Source(16, 74) + SourceIndex(0) -29>Emitted(12, 103) Source(16, 75) + SourceIndex(0) +1->Emitted(12, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(12, 32) Source(15, 16) + SourceIndex(0) +3 >Emitted(12, 35) Source(15, 9) + SourceIndex(0) +4 >Emitted(12, 49) Source(15, 21) + SourceIndex(0) +5 >Emitted(12, 55) Source(15, 27) + SourceIndex(0) +6 >Emitted(12, 56) Source(15, 28) + SourceIndex(0) +7 >Emitted(12, 60) Source(15, 32) + SourceIndex(0) +8 >Emitted(12, 61) Source(15, 33) + SourceIndex(0) +9 >Emitted(12, 65) Source(15, 37) + SourceIndex(0) +10>Emitted(12, 66) Source(15, 38) + SourceIndex(0) +11>Emitted(12, 70) Source(15, 42) + SourceIndex(0) +12>Emitted(12, 71) Source(15, 43) + SourceIndex(0) +13>Emitted(12, 72) Source(15, 44) + SourceIndex(0) +14>Emitted(12, 75) Source(15, 47) + SourceIndex(0) +15>Emitted(12, 79) Source(15, 51) + SourceIndex(0) +16>Emitted(12, 80) Source(15, 52) + SourceIndex(0) +17>Emitted(12, 81) Source(15, 53) + SourceIndex(0) +18>Emitted(12, 84) Source(15, 56) + SourceIndex(0) +19>Emitted(12, 88) Source(15, 60) + SourceIndex(0) +20>Emitted(12, 89) Source(15, 61) + SourceIndex(0) +21>Emitted(12, 90) Source(15, 62) + SourceIndex(0) +22>Emitted(12, 93) Source(15, 65) + SourceIndex(0) +23>Emitted(12, 97) Source(15, 69) + SourceIndex(0) +24>Emitted(12, 98) Source(15, 70) + SourceIndex(0) +25>Emitted(12, 99) Source(15, 71) + SourceIndex(0) +26>Emitted(12, 100) Source(15, 72) + SourceIndex(0) +27>Emitted(12, 101) Source(15, 73) + SourceIndex(0) +28>Emitted(12, 102) Source(15, 74) + SourceIndex(0) +29>Emitted(12, 103) Source(15, 75) + SourceIndex(0) --- >>> return Point; 1 >^^^^^^^^ @@ -274,8 +273,8 @@ sourceFile:sourceMap-FileWithComments.ts > static origin = new Point(0, 0); > 2 > } -1 >Emitted(13, 9) Source(20, 5) + SourceIndex(0) -2 >Emitted(13, 21) Source(20, 6) + SourceIndex(0) +1 >Emitted(13, 9) Source(19, 5) + SourceIndex(0) +2 >Emitted(13, 21) Source(19, 6) + SourceIndex(0) --- >>> }()); 1 >^^^^ @@ -285,9 +284,9 @@ sourceFile:sourceMap-FileWithComments.ts 1 > 2 > } 3 > -1 >Emitted(14, 5) Source(20, 5) + SourceIndex(0) -2 >Emitted(14, 6) Source(20, 6) + SourceIndex(0) -3 >Emitted(14, 6) Source(11, 5) + SourceIndex(0) +1 >Emitted(14, 5) Source(19, 5) + SourceIndex(0) +2 >Emitted(14, 6) Source(19, 6) + SourceIndex(0) +3 >Emitted(14, 6) Source(10, 5) + SourceIndex(0) --- >>> // Static member 1->^^^^ @@ -302,8 +301,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Static member -1->Emitted(15, 5) Source(18, 9) + SourceIndex(0) -2 >Emitted(15, 21) Source(18, 25) + SourceIndex(0) +1->Emitted(15, 5) Source(17, 9) + SourceIndex(0) +2 >Emitted(15, 21) Source(17, 25) + SourceIndex(0) --- >>> Point.origin = new Point(0, 0); 1->^^^^ @@ -329,17 +328,17 @@ sourceFile:sourceMap-FileWithComments.ts 9 > 0 10> ) 11> ; -1->Emitted(16, 5) Source(19, 16) + SourceIndex(0) -2 >Emitted(16, 17) Source(19, 22) + SourceIndex(0) -3 >Emitted(16, 20) Source(19, 25) + SourceIndex(0) -4 >Emitted(16, 24) Source(19, 29) + SourceIndex(0) -5 >Emitted(16, 29) Source(19, 34) + SourceIndex(0) -6 >Emitted(16, 30) Source(19, 35) + SourceIndex(0) -7 >Emitted(16, 31) Source(19, 36) + SourceIndex(0) -8 >Emitted(16, 33) Source(19, 38) + SourceIndex(0) -9 >Emitted(16, 34) Source(19, 39) + SourceIndex(0) -10>Emitted(16, 35) Source(19, 40) + SourceIndex(0) -11>Emitted(16, 36) Source(19, 41) + SourceIndex(0) +1->Emitted(16, 5) Source(18, 16) + SourceIndex(0) +2 >Emitted(16, 17) Source(18, 22) + SourceIndex(0) +3 >Emitted(16, 20) Source(18, 25) + SourceIndex(0) +4 >Emitted(16, 24) Source(18, 29) + SourceIndex(0) +5 >Emitted(16, 29) Source(18, 34) + SourceIndex(0) +6 >Emitted(16, 30) Source(18, 35) + SourceIndex(0) +7 >Emitted(16, 31) Source(18, 36) + SourceIndex(0) +8 >Emitted(16, 33) Source(18, 38) + SourceIndex(0) +9 >Emitted(16, 34) Source(18, 39) + SourceIndex(0) +10>Emitted(16, 35) Source(18, 40) + SourceIndex(0) +11>Emitted(16, 36) Source(18, 41) + SourceIndex(0) --- >>> Shapes.Point = Point; 1 >^^^^ @@ -360,10 +359,10 @@ sourceFile:sourceMap-FileWithComments.ts > static origin = new Point(0, 0); > } 4 > -1 >Emitted(17, 5) Source(11, 18) + SourceIndex(0) -2 >Emitted(17, 17) Source(11, 23) + SourceIndex(0) -3 >Emitted(17, 25) Source(20, 6) + SourceIndex(0) -4 >Emitted(17, 26) Source(20, 6) + SourceIndex(0) +1 >Emitted(17, 5) Source(10, 18) + SourceIndex(0) +2 >Emitted(17, 17) Source(10, 23) + SourceIndex(0) +3 >Emitted(17, 25) Source(19, 6) + SourceIndex(0) +4 >Emitted(17, 26) Source(19, 6) + SourceIndex(0) --- >>> // Variable comment after class 1->^^^^ @@ -372,8 +371,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Variable comment after class -1->Emitted(18, 5) Source(22, 5) + SourceIndex(0) -2 >Emitted(18, 36) Source(22, 36) + SourceIndex(0) +1->Emitted(18, 5) Source(21, 5) + SourceIndex(0) +2 >Emitted(18, 36) Source(21, 36) + SourceIndex(0) --- >>> var a = 10; 1 >^^^^ @@ -390,12 +389,12 @@ sourceFile:sourceMap-FileWithComments.ts 4 > = 5 > 10 6 > ; -1 >Emitted(19, 5) Source(23, 5) + SourceIndex(0) -2 >Emitted(19, 9) Source(23, 9) + SourceIndex(0) -3 >Emitted(19, 10) Source(23, 10) + SourceIndex(0) -4 >Emitted(19, 13) Source(23, 13) + SourceIndex(0) -5 >Emitted(19, 15) Source(23, 15) + SourceIndex(0) -6 >Emitted(19, 16) Source(23, 16) + SourceIndex(0) +1 >Emitted(19, 5) Source(22, 5) + SourceIndex(0) +2 >Emitted(19, 9) Source(22, 9) + SourceIndex(0) +3 >Emitted(19, 10) Source(22, 10) + SourceIndex(0) +4 >Emitted(19, 13) Source(22, 13) + SourceIndex(0) +5 >Emitted(19, 15) Source(22, 15) + SourceIndex(0) +6 >Emitted(19, 16) Source(22, 16) + SourceIndex(0) --- >>> function foo() { 1->^^^^ @@ -403,7 +402,7 @@ sourceFile:sourceMap-FileWithComments.ts 1-> > > -1->Emitted(20, 5) Source(25, 5) + SourceIndex(0) +1->Emitted(20, 5) Source(24, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -412,8 +411,8 @@ sourceFile:sourceMap-FileWithComments.ts 1->export function foo() { > 2 > } -1->Emitted(21, 5) Source(26, 5) + SourceIndex(0) -2 >Emitted(21, 6) Source(26, 6) + SourceIndex(0) +1->Emitted(21, 5) Source(25, 5) + SourceIndex(0) +2 >Emitted(21, 6) Source(25, 6) + SourceIndex(0) --- >>> Shapes.foo = foo; 1->^^^^ @@ -426,10 +425,10 @@ sourceFile:sourceMap-FileWithComments.ts 3 > () { > } 4 > -1->Emitted(22, 5) Source(25, 21) + SourceIndex(0) -2 >Emitted(22, 15) Source(25, 24) + SourceIndex(0) -3 >Emitted(22, 21) Source(26, 6) + SourceIndex(0) -4 >Emitted(22, 22) Source(26, 6) + SourceIndex(0) +1->Emitted(22, 5) Source(24, 21) + SourceIndex(0) +2 >Emitted(22, 15) Source(24, 24) + SourceIndex(0) +3 >Emitted(22, 21) Source(25, 6) + SourceIndex(0) +4 >Emitted(22, 22) Source(25, 6) + SourceIndex(0) --- >>> /** comment after function 1->^^^^ @@ -437,7 +436,7 @@ sourceFile:sourceMap-FileWithComments.ts 1-> > > -1->Emitted(23, 5) Source(28, 5) + SourceIndex(0) +1->Emitted(23, 5) Source(27, 5) + SourceIndex(0) --- >>> * this is another comment >>> */ @@ -446,7 +445,7 @@ sourceFile:sourceMap-FileWithComments.ts 1->/** comment after function > * this is another comment > */ -1->Emitted(25, 7) Source(30, 7) + SourceIndex(0) +1->Emitted(25, 7) Source(29, 7) + SourceIndex(0) --- >>> var b = 10; 1->^^^^ @@ -463,12 +462,12 @@ sourceFile:sourceMap-FileWithComments.ts 4 > = 5 > 10 6 > ; -1->Emitted(26, 5) Source(31, 5) + SourceIndex(0) -2 >Emitted(26, 9) Source(31, 9) + SourceIndex(0) -3 >Emitted(26, 10) Source(31, 10) + SourceIndex(0) -4 >Emitted(26, 13) Source(31, 13) + SourceIndex(0) -5 >Emitted(26, 15) Source(31, 15) + SourceIndex(0) -6 >Emitted(26, 16) Source(31, 16) + SourceIndex(0) +1->Emitted(26, 5) Source(30, 5) + SourceIndex(0) +2 >Emitted(26, 9) Source(30, 9) + SourceIndex(0) +3 >Emitted(26, 10) Source(30, 10) + SourceIndex(0) +4 >Emitted(26, 13) Source(30, 13) + SourceIndex(0) +5 >Emitted(26, 15) Source(30, 15) + SourceIndex(0) +6 >Emitted(26, 16) Source(30, 16) + SourceIndex(0) --- >>>})(Shapes || (Shapes = {})); 1-> @@ -510,13 +509,13 @@ sourceFile:sourceMap-FileWithComments.ts > */ > var b = 10; > } -1->Emitted(27, 1) Source(32, 1) + SourceIndex(0) -2 >Emitted(27, 2) Source(32, 2) + SourceIndex(0) -3 >Emitted(27, 4) Source(8, 8) + SourceIndex(0) -4 >Emitted(27, 10) Source(8, 14) + SourceIndex(0) -5 >Emitted(27, 15) Source(8, 8) + SourceIndex(0) -6 >Emitted(27, 21) Source(8, 14) + SourceIndex(0) -7 >Emitted(27, 29) Source(32, 2) + SourceIndex(0) +1->Emitted(27, 1) Source(31, 1) + SourceIndex(0) +2 >Emitted(27, 2) Source(31, 2) + SourceIndex(0) +3 >Emitted(27, 4) Source(7, 8) + SourceIndex(0) +4 >Emitted(27, 10) Source(7, 14) + SourceIndex(0) +5 >Emitted(27, 15) Source(7, 8) + SourceIndex(0) +6 >Emitted(27, 21) Source(7, 14) + SourceIndex(0) +7 >Emitted(27, 29) Source(31, 2) + SourceIndex(0) --- >>>/** Local Variable */ 1 > @@ -526,8 +525,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 >/** Local Variable */ -1 >Emitted(28, 1) Source(34, 1) + SourceIndex(0) -2 >Emitted(28, 22) Source(34, 22) + SourceIndex(0) +1 >Emitted(28, 1) Source(33, 1) + SourceIndex(0) +2 >Emitted(28, 22) Source(33, 22) + SourceIndex(0) --- >>>var p = new Shapes.Point(3, 4); 1-> @@ -559,20 +558,20 @@ sourceFile:sourceMap-FileWithComments.ts 12> 4 13> ) 14> ; -1->Emitted(29, 1) Source(35, 1) + SourceIndex(0) -2 >Emitted(29, 5) Source(35, 5) + SourceIndex(0) -3 >Emitted(29, 6) Source(35, 6) + SourceIndex(0) -4 >Emitted(29, 9) Source(35, 17) + SourceIndex(0) -5 >Emitted(29, 13) Source(35, 21) + SourceIndex(0) -6 >Emitted(29, 19) Source(35, 27) + SourceIndex(0) -7 >Emitted(29, 20) Source(35, 28) + SourceIndex(0) -8 >Emitted(29, 25) Source(35, 33) + SourceIndex(0) -9 >Emitted(29, 26) Source(35, 34) + SourceIndex(0) -10>Emitted(29, 27) Source(35, 35) + SourceIndex(0) -11>Emitted(29, 29) Source(35, 37) + SourceIndex(0) -12>Emitted(29, 30) Source(35, 38) + SourceIndex(0) -13>Emitted(29, 31) Source(35, 39) + SourceIndex(0) -14>Emitted(29, 32) Source(35, 40) + SourceIndex(0) +1->Emitted(29, 1) Source(34, 1) + SourceIndex(0) +2 >Emitted(29, 5) Source(34, 5) + SourceIndex(0) +3 >Emitted(29, 6) Source(34, 6) + SourceIndex(0) +4 >Emitted(29, 9) Source(34, 17) + SourceIndex(0) +5 >Emitted(29, 13) Source(34, 21) + SourceIndex(0) +6 >Emitted(29, 19) Source(34, 27) + SourceIndex(0) +7 >Emitted(29, 20) Source(34, 28) + SourceIndex(0) +8 >Emitted(29, 25) Source(34, 33) + SourceIndex(0) +9 >Emitted(29, 26) Source(34, 34) + SourceIndex(0) +10>Emitted(29, 27) Source(34, 35) + SourceIndex(0) +11>Emitted(29, 29) Source(34, 37) + SourceIndex(0) +12>Emitted(29, 30) Source(34, 38) + SourceIndex(0) +13>Emitted(29, 31) Source(34, 39) + SourceIndex(0) +14>Emitted(29, 32) Source(34, 40) + SourceIndex(0) --- >>>var dist = p.getDist(); 1 > @@ -595,14 +594,14 @@ sourceFile:sourceMap-FileWithComments.ts 7 > getDist 8 > () 9 > ; -1 >Emitted(30, 1) Source(36, 1) + SourceIndex(0) -2 >Emitted(30, 5) Source(36, 5) + SourceIndex(0) -3 >Emitted(30, 9) Source(36, 9) + SourceIndex(0) -4 >Emitted(30, 12) Source(36, 12) + SourceIndex(0) -5 >Emitted(30, 13) Source(36, 13) + SourceIndex(0) -6 >Emitted(30, 14) Source(36, 14) + SourceIndex(0) -7 >Emitted(30, 21) Source(36, 21) + SourceIndex(0) -8 >Emitted(30, 23) Source(36, 23) + SourceIndex(0) -9 >Emitted(30, 24) Source(36, 24) + SourceIndex(0) +1 >Emitted(30, 1) Source(35, 1) + SourceIndex(0) +2 >Emitted(30, 5) Source(35, 5) + SourceIndex(0) +3 >Emitted(30, 9) Source(35, 9) + SourceIndex(0) +4 >Emitted(30, 12) Source(35, 12) + SourceIndex(0) +5 >Emitted(30, 13) Source(35, 13) + SourceIndex(0) +6 >Emitted(30, 14) Source(35, 14) + SourceIndex(0) +7 >Emitted(30, 21) Source(35, 21) + SourceIndex(0) +8 >Emitted(30, 23) Source(35, 23) + SourceIndex(0) +9 >Emitted(30, 24) Source(35, 24) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMap-FileWithComments.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-FileWithComments.symbols b/tests/baselines/reference/sourceMap-FileWithComments.symbols index e7b8c1c4b7c..70135a317d0 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.symbols +++ b/tests/baselines/reference/sourceMap-FileWithComments.symbols @@ -1,78 +1,77 @@ === tests/cases/compiler/sourceMap-FileWithComments.ts === - // Interface interface IPoint { >IPoint : Symbol(IPoint, Decl(sourceMap-FileWithComments.ts, 0, 0)) getDist(): number; ->getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 2, 18)) +>getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 1, 18)) } // Module module Shapes { ->Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 4, 1)) +>Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 3, 1)) // Class export class Point implements IPoint { ->Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) +>Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) >IPoint : Symbol(IPoint, Decl(sourceMap-FileWithComments.ts, 0, 0)) // Constructor constructor(public x: number, public y: number) { } ->x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) +>x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) // Instance member getDist() { return Math.sqrt(this.x * this.x + this.y * this.y); } ->getDist : Symbol(Point.getDist, Decl(sourceMap-FileWithComments.ts, 12, 59)) +>getDist : Symbol(Point.getDist, Decl(sourceMap-FileWithComments.ts, 11, 59)) >Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) ->this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) ->this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) +>this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) +>this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) // Static member static origin = new Point(0, 0); ->origin : Symbol(Point.origin, Decl(sourceMap-FileWithComments.ts, 15, 74)) ->Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) +>origin : Symbol(Point.origin, Decl(sourceMap-FileWithComments.ts, 14, 74)) +>Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) } // Variable comment after class var a = 10; ->a : Symbol(a, Decl(sourceMap-FileWithComments.ts, 22, 7)) +>a : Symbol(a, Decl(sourceMap-FileWithComments.ts, 21, 7)) export function foo() { ->foo : Symbol(foo, Decl(sourceMap-FileWithComments.ts, 22, 15)) +>foo : Symbol(foo, Decl(sourceMap-FileWithComments.ts, 21, 15)) } /** comment after function * this is another comment */ var b = 10; ->b : Symbol(b, Decl(sourceMap-FileWithComments.ts, 30, 7)) +>b : Symbol(b, Decl(sourceMap-FileWithComments.ts, 29, 7)) } /** Local Variable */ var p: IPoint = new Shapes.Point(3, 4); ->p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 34, 3)) +>p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 33, 3)) >IPoint : Symbol(IPoint, Decl(sourceMap-FileWithComments.ts, 0, 0)) ->Shapes.Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 4, 1)) ->Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) +>Shapes.Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 3, 1)) +>Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) var dist = p.getDist(); ->dist : Symbol(dist, Decl(sourceMap-FileWithComments.ts, 35, 3)) ->p.getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 2, 18)) ->p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 34, 3)) ->getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 2, 18)) +>dist : Symbol(dist, Decl(sourceMap-FileWithComments.ts, 34, 3)) +>p.getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 1, 18)) +>p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 33, 3)) +>getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 1, 18)) diff --git a/tests/baselines/reference/sourceMap-FileWithComments.types b/tests/baselines/reference/sourceMap-FileWithComments.types index 2198fa9a590..cfb6ececffd 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.types +++ b/tests/baselines/reference/sourceMap-FileWithComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMap-FileWithComments.ts === - // Interface interface IPoint { >IPoint : IPoint diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js index 01d784be7f8..699c1b68e28 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js @@ -1,5 +1,4 @@ //// [sourceMap-InterfacePrecedingVariableDeclaration1.ts] - interface I {} var x = 0; diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map index a83a47f887a..7b56fdcf290 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map @@ -1,2 +1,2 @@ //// [sourceMap-InterfacePrecedingVariableDeclaration1.js.map] -{"version":3,"file":"sourceMap-InterfacePrecedingVariableDeclaration1.js","sourceRoot":"","sources":["sourceMap-InterfacePrecedingVariableDeclaration1.ts"],"names":[],"mappings":"AAEA,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMap-InterfacePrecedingVariableDeclaration1.js","sourceRoot":"","sources":["sourceMap-InterfacePrecedingVariableDeclaration1.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt index f409fa206ea..6a67f65b561 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt @@ -16,19 +16,18 @@ sourceFile:sourceMap-InterfacePrecedingVariableDeclaration1.ts 5 > ^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >interface I {} +1 >interface I {} > 2 >var 3 > x 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(3, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(3, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(3, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(3, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMap-InterfacePrecedingVariableDeclaration1.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols index 7de2b91464d..bb94e55cda2 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/sourceMap-InterfacePrecedingVariableDeclaration1.ts === - interface I {} >I : Symbol(I, Decl(sourceMap-InterfacePrecedingVariableDeclaration1.ts, 0, 0)) var x = 0; ->x : Symbol(x, Decl(sourceMap-InterfacePrecedingVariableDeclaration1.ts, 2, 3)) +>x : Symbol(x, Decl(sourceMap-InterfacePrecedingVariableDeclaration1.ts, 1, 3)) diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types index 5faca1a4ddb..7bf55220d28 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMap-InterfacePrecedingVariableDeclaration1.ts === - interface I {} >I : I diff --git a/tests/baselines/reference/sourceMap-NewLine1.js b/tests/baselines/reference/sourceMap-NewLine1.js index 7f2bb6cd314..47801427eec 100644 --- a/tests/baselines/reference/sourceMap-NewLine1.js +++ b/tests/baselines/reference/sourceMap-NewLine1.js @@ -1,5 +1,4 @@ //// [sourceMap-NewLine1.ts] - //// [sourceMap-NewLine1.js] diff --git a/tests/baselines/reference/sourceMap-NewLine1.symbols b/tests/baselines/reference/sourceMap-NewLine1.symbols index a9097264f4e..4473db86e82 100644 --- a/tests/baselines/reference/sourceMap-NewLine1.symbols +++ b/tests/baselines/reference/sourceMap-NewLine1.symbols @@ -1,4 +1,3 @@ === tests/cases/compiler/sourceMap-NewLine1.ts === -No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-NewLine1.types b/tests/baselines/reference/sourceMap-NewLine1.types index a9097264f4e..4473db86e82 100644 --- a/tests/baselines/reference/sourceMap-NewLine1.types +++ b/tests/baselines/reference/sourceMap-NewLine1.types @@ -1,4 +1,3 @@ === tests/cases/compiler/sourceMap-NewLine1.ts === -No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js index 8745facb3a6..3404a5ee04c 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js @@ -1,5 +1,4 @@ //// [sourceMap-StringLiteralWithNewLine.ts] - interface Document { } interface Window { diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map index c86a8937ed7..003b442399e 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map @@ -1,2 +1,2 @@ //// [sourceMap-StringLiteralWithNewLine.js.map] -{"version":3,"file":"sourceMap-StringLiteralWithNewLine.js","sourceRoot":"","sources":["sourceMap-StringLiteralWithNewLine.ts"],"names":[],"mappings":"AAQA,IAAO,GAAG,CAKT;AALD,WAAO,GAAG;IACN,IAAI,CAAC,GAAG,OAAO,CAAC;IAChB,IAAI,CAAC,GAAG;wBACY,CAAC;IACrB,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;AAC5B,CAAC,EALM,GAAG,KAAH,GAAG,QAKT"} \ No newline at end of file +{"version":3,"file":"sourceMap-StringLiteralWithNewLine.js","sourceRoot":"","sources":["sourceMap-StringLiteralWithNewLine.ts"],"names":[],"mappings":"AAOA,IAAO,GAAG,CAKT;AALD,WAAO,GAAG;IACN,IAAI,CAAC,GAAG,OAAO,CAAC;IAChB,IAAI,CAAC,GAAG;wBACY,CAAC;IACrB,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;AAC5B,CAAC,EALM,GAAG,KAAH,GAAG,QAKT"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt index f4c60842ea9..f7f0607ba01 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt @@ -14,8 +14,7 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 3 > ^^^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >interface Document { +1 >interface Document { >} >interface Window { > document: Document; @@ -31,10 +30,10 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts > isn't this a lot of fun"; > var z = window.document; > } -1 >Emitted(1, 1) Source(9, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(9, 8) + SourceIndex(0) -3 >Emitted(1, 8) Source(9, 11) + SourceIndex(0) -4 >Emitted(1, 9) Source(14, 2) + SourceIndex(0) +1 >Emitted(1, 1) Source(8, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(8, 8) + SourceIndex(0) +3 >Emitted(1, 8) Source(8, 11) + SourceIndex(0) +4 >Emitted(1, 9) Source(13, 2) + SourceIndex(0) --- >>>(function (Foo) { 1-> @@ -44,9 +43,9 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 1-> 2 >module 3 > Foo -1->Emitted(2, 1) Source(9, 1) + SourceIndex(0) -2 >Emitted(2, 12) Source(9, 8) + SourceIndex(0) -3 >Emitted(2, 15) Source(9, 11) + SourceIndex(0) +1->Emitted(2, 1) Source(8, 1) + SourceIndex(0) +2 >Emitted(2, 12) Source(8, 8) + SourceIndex(0) +3 >Emitted(2, 15) Source(8, 11) + SourceIndex(0) --- >>> var x = "test1"; 1->^^^^ @@ -62,12 +61,12 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 4 > = 5 > "test1" 6 > ; -1->Emitted(3, 5) Source(10, 5) + SourceIndex(0) -2 >Emitted(3, 9) Source(10, 9) + SourceIndex(0) -3 >Emitted(3, 10) Source(10, 10) + SourceIndex(0) -4 >Emitted(3, 13) Source(10, 13) + SourceIndex(0) -5 >Emitted(3, 20) Source(10, 20) + SourceIndex(0) -6 >Emitted(3, 21) Source(10, 21) + SourceIndex(0) +1->Emitted(3, 5) Source(9, 5) + SourceIndex(0) +2 >Emitted(3, 9) Source(9, 9) + SourceIndex(0) +3 >Emitted(3, 10) Source(9, 10) + SourceIndex(0) +4 >Emitted(3, 13) Source(9, 13) + SourceIndex(0) +5 >Emitted(3, 20) Source(9, 20) + SourceIndex(0) +6 >Emitted(3, 21) Source(9, 21) + SourceIndex(0) --- >>> var y = "test 2\ 1 >^^^^ @@ -80,10 +79,10 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 2 > var 3 > y 4 > = -1 >Emitted(4, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(4, 9) Source(11, 9) + SourceIndex(0) -3 >Emitted(4, 10) Source(11, 10) + SourceIndex(0) -4 >Emitted(4, 13) Source(11, 13) + SourceIndex(0) +1 >Emitted(4, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(4, 9) Source(10, 9) + SourceIndex(0) +3 >Emitted(4, 10) Source(10, 10) + SourceIndex(0) +4 >Emitted(4, 13) Source(10, 13) + SourceIndex(0) --- >>>isn't this a lot of fun"; 1->^^^^^^^^^^^^^^^^^^^^^^^^ @@ -92,8 +91,8 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 1->"test 2\ >isn't this a lot of fun" 2 > ; -1->Emitted(5, 25) Source(12, 25) + SourceIndex(0) -2 >Emitted(5, 26) Source(12, 26) + SourceIndex(0) +1->Emitted(5, 25) Source(11, 25) + SourceIndex(0) +2 >Emitted(5, 26) Source(11, 26) + SourceIndex(0) --- >>> var z = window.document; 1->^^^^ @@ -113,14 +112,14 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 6 > . 7 > document 8 > ; -1->Emitted(6, 5) Source(13, 5) + SourceIndex(0) -2 >Emitted(6, 9) Source(13, 9) + SourceIndex(0) -3 >Emitted(6, 10) Source(13, 10) + SourceIndex(0) -4 >Emitted(6, 13) Source(13, 13) + SourceIndex(0) -5 >Emitted(6, 19) Source(13, 19) + SourceIndex(0) -6 >Emitted(6, 20) Source(13, 20) + SourceIndex(0) -7 >Emitted(6, 28) Source(13, 28) + SourceIndex(0) -8 >Emitted(6, 29) Source(13, 29) + SourceIndex(0) +1->Emitted(6, 5) Source(12, 5) + SourceIndex(0) +2 >Emitted(6, 9) Source(12, 9) + SourceIndex(0) +3 >Emitted(6, 10) Source(12, 10) + SourceIndex(0) +4 >Emitted(6, 13) Source(12, 13) + SourceIndex(0) +5 >Emitted(6, 19) Source(12, 19) + SourceIndex(0) +6 >Emitted(6, 20) Source(12, 20) + SourceIndex(0) +7 >Emitted(6, 28) Source(12, 28) + SourceIndex(0) +8 >Emitted(6, 29) Source(12, 29) + SourceIndex(0) --- >>>})(Foo || (Foo = {})); 1 > @@ -144,12 +143,12 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts > isn't this a lot of fun"; > var z = window.document; > } -1 >Emitted(7, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(7, 2) Source(14, 2) + SourceIndex(0) -3 >Emitted(7, 4) Source(9, 8) + SourceIndex(0) -4 >Emitted(7, 7) Source(9, 11) + SourceIndex(0) -5 >Emitted(7, 12) Source(9, 8) + SourceIndex(0) -6 >Emitted(7, 15) Source(9, 11) + SourceIndex(0) -7 >Emitted(7, 23) Source(14, 2) + SourceIndex(0) +1 >Emitted(7, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(7, 2) Source(13, 2) + SourceIndex(0) +3 >Emitted(7, 4) Source(8, 8) + SourceIndex(0) +4 >Emitted(7, 7) Source(8, 11) + SourceIndex(0) +5 >Emitted(7, 12) Source(8, 8) + SourceIndex(0) +6 >Emitted(7, 15) Source(8, 11) + SourceIndex(0) +7 >Emitted(7, 23) Source(13, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMap-StringLiteralWithNewLine.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols index 3b1d95afc00..d6038b946ef 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols @@ -1,32 +1,31 @@ === tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts === - interface Document { >Document : Symbol(Document, Decl(sourceMap-StringLiteralWithNewLine.ts, 0, 0)) } interface Window { ->Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 1)) +>Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 1, 1)) document: Document; ->document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 3, 18)) +>document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 18)) >Document : Symbol(Document, Decl(sourceMap-StringLiteralWithNewLine.ts, 0, 0)) } declare var window: Window; ->window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 6, 11)) ->Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 1)) +>window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 5, 11)) +>Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 1, 1)) module Foo { ->Foo : Symbol(Foo, Decl(sourceMap-StringLiteralWithNewLine.ts, 6, 27)) +>Foo : Symbol(Foo, Decl(sourceMap-StringLiteralWithNewLine.ts, 5, 27)) var x = "test1"; ->x : Symbol(x, Decl(sourceMap-StringLiteralWithNewLine.ts, 9, 7)) +>x : Symbol(x, Decl(sourceMap-StringLiteralWithNewLine.ts, 8, 7)) var y = "test 2\ ->y : Symbol(y, Decl(sourceMap-StringLiteralWithNewLine.ts, 10, 7)) +>y : Symbol(y, Decl(sourceMap-StringLiteralWithNewLine.ts, 9, 7)) isn't this a lot of fun"; var z = window.document; ->z : Symbol(z, Decl(sourceMap-StringLiteralWithNewLine.ts, 12, 7)) ->window.document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 3, 18)) ->window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 6, 11)) ->document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 3, 18)) +>z : Symbol(z, Decl(sourceMap-StringLiteralWithNewLine.ts, 11, 7)) +>window.document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 18)) +>window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 5, 11)) +>document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 18)) } diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types index 26bfd605b95..9a7e416b907 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts === - interface Document { >Document : Document } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js index d4c419278c7..3db1230db06 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts] - var [x] = [1, 2]; //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map index faa5e070b0a..191d39ee6d3 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts"],"names":[],"mappings":"AACK,IAAA,aAAC,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts"],"names":[],"mappings":"AAAK,IAAA,aAAC,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt index 0499d382d10..1f721ceb2be 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt @@ -14,14 +14,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern4 3 > ^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var [ +1 >var [ 2 > 3 > x 4 > ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 18) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 19) Source(2, 18) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 18) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 19) Source(1, 18) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols index 4695a8cd598..560f3b4c9fd 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts === - var [x] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts, 0, 5)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types index 4f61c672b81..052cb7777a1 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts === - var [x] = [1, 2]; >x : number >[1, 2] : [number, number] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js index 10df853c220..df45d144071 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts] - var [x] = [1, 2]; var [y, z] = [1, 2]; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map index 31ad84b4b44..456a64e7f34 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts"],"names":[],"mappings":"AACK,IAAA,aAAC,CAAW;AACb,IAAA,WAAe,EAAd,SAAC,EAAE,SAAC,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts"],"names":[],"mappings":"AAAK,IAAA,aAAC,CAAW;AACb,IAAA,WAAe,EAAd,SAAC,EAAE,SAAC,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt index 1775f60ffe0..2603b53c456 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt @@ -14,15 +14,14 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern5 3 > ^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var [ +1 >var [ 2 > 3 > x 4 > ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 18) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 19) Source(2, 18) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 18) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 19) Source(1, 18) + SourceIndex(0) --- >>>var _a = [1, 2], y = _a[0], z = _a[1]; 1-> @@ -43,13 +42,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern5 6 > , 7 > z 8 > ] = [1, 2]; -1->Emitted(2, 1) Source(3, 5) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 16) Source(3, 20) + SourceIndex(0) -4 >Emitted(2, 18) Source(3, 6) + SourceIndex(0) -5 >Emitted(2, 27) Source(3, 7) + SourceIndex(0) -6 >Emitted(2, 29) Source(3, 9) + SourceIndex(0) -7 >Emitted(2, 38) Source(3, 10) + SourceIndex(0) -8 >Emitted(2, 39) Source(3, 21) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 5) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 16) Source(2, 20) + SourceIndex(0) +4 >Emitted(2, 18) Source(2, 6) + SourceIndex(0) +5 >Emitted(2, 27) Source(2, 7) + SourceIndex(0) +6 >Emitted(2, 29) Source(2, 9) + SourceIndex(0) +7 >Emitted(2, 38) Source(2, 10) + SourceIndex(0) +8 >Emitted(2, 39) Source(2, 21) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols index 59543290772..ad0be4d90b3 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts === - var [x] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 0, 5)) var [y, z] = [1, 2]; ->y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 2, 5)) ->z : Symbol(z, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 2, 7)) +>y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 1, 5)) +>z : Symbol(z, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 1, 7)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types index 908e566ca71..3061ce7e9d3 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts === - var [x] = [1, 2]; >x : number >[1, 2] : [number, number] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js index d4baadb6562..02efbda7b18 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts] - var [x = 20] = [1, 2]; //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map index 1271129d1c9..309dc1595ab 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts"],"names":[],"mappings":"AACK,IAAA,cAAM,EAAN,2BAAM,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts"],"names":[],"mappings":"AAAK,IAAA,cAAM,EAAN,2BAAM,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt index 2dadb2f5352..8f971d65cd7 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt @@ -16,18 +16,17 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern6 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var [ +1 >var [ 2 > 3 > x = 20 4 > 5 > x = 20 6 > ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 19) Source(2, 12) + SourceIndex(0) -4 >Emitted(1, 21) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 48) Source(2, 12) + SourceIndex(0) -6 >Emitted(1, 49) Source(2, 23) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 19) Source(1, 12) + SourceIndex(0) +4 >Emitted(1, 21) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 48) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 49) Source(1, 23) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols index 6c368f4996e..4a478cdeee7 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts === - var [x = 20] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts, 0, 5)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types index 166a6192bb7..61b32753bf7 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts === - var [x = 20] = [1, 2]; >x : number >20 : 20 diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js index 73d2e85e9da..720004a3c11 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts] - var [x = 20, j] = [1, 2]; //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map index eb0df6f9ca2..94422f76145 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts"],"names":[],"mappings":"AACI,IAAA,WAAoB,EAAnB,UAAM,EAAN,2BAAM,EAAE,SAAC,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts"],"names":[],"mappings":"AAAI,IAAA,WAAoB,EAAnB,UAAM,EAAN,2BAAM,EAAE,SAAC,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt index e4b2c871cb1..2a088a1dc82 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt @@ -20,8 +20,7 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern7 9 > ^^^^^^^^^ 10> ^ 11> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var +1 >var 2 > 3 > [x = 20, j] = [1, 2] 4 > @@ -31,15 +30,15 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern7 8 > , 9 > j 10> ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 5) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 16) Source(2, 25) + SourceIndex(0) -4 >Emitted(1, 18) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 28) Source(2, 12) + SourceIndex(0) -6 >Emitted(1, 30) Source(2, 6) + SourceIndex(0) -7 >Emitted(1, 57) Source(2, 12) + SourceIndex(0) -8 >Emitted(1, 59) Source(2, 14) + SourceIndex(0) -9 >Emitted(1, 68) Source(2, 15) + SourceIndex(0) -10>Emitted(1, 69) Source(2, 26) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 5) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 16) Source(1, 25) + SourceIndex(0) +4 >Emitted(1, 18) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 28) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 30) Source(1, 6) + SourceIndex(0) +7 >Emitted(1, 57) Source(1, 12) + SourceIndex(0) +8 >Emitted(1, 59) Source(1, 14) + SourceIndex(0) +9 >Emitted(1, 68) Source(1, 15) + SourceIndex(0) +10>Emitted(1, 69) Source(1, 26) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols index 4f57dffff26..83e97204816 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts === - var [x = 20, j] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 1, 5)) ->j : Symbol(j, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 1, 12)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 0, 5)) +>j : Symbol(j, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 0, 12)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types index da537c6e109..6b6e6c2c722 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts === - var [x = 20, j] = [1, 2]; >x : number >20 : 20 diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js index 8259981857c..a20e7578d93 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts] - var {x} = { x: 20 }; //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map index 71a3949b553..b0a552391c9 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts"],"names":[],"mappings":"AACK,IAAA,eAAC,CAAc"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts"],"names":[],"mappings":"AAAK,IAAA,eAAC,CAAc"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt index 829e0d19195..0c554c986a4 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt @@ -14,14 +14,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 3 > ^^^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var { +1 >var { 2 > 3 > x 4 > } = { x: 20 }; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 20) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 21) Source(2, 21) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 20) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 21) Source(1, 21) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols index 950fca4eb00..a0c5682074d 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts === - var {x} = { x: 20 }; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 1, 5)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 1, 11)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 0, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 0, 11)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types index 14995bbe1c9..b80df17fe67 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts === - var {x} = { x: 20 }; >x : number >{ x: 20 } : { x: number; } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js index d4d52e5e8d9..44295762d6d 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts] - var {x} = { x: 20 }; var { a, b } = { a: 30, b: 40 }; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map index 7eda5a24bdb..eb36a3b9022 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts"],"names":[],"mappings":"AACK,IAAA,eAAC,CAAc;AAChB,IAAA,qBAA2B,EAAzB,QAAC,EAAE,QAAC,CAAsB"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts"],"names":[],"mappings":"AAAK,IAAA,eAAC,CAAc;AAChB,IAAA,qBAA2B,EAAzB,QAAC,EAAE,QAAC,CAAsB"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt index 380c6e2b14e..2390f91a8b1 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt @@ -14,15 +14,14 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 3 > ^^^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var { +1 >var { 2 > 3 > x 4 > } = { x: 20 }; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 20) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 21) Source(2, 21) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 20) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 21) Source(1, 21) + SourceIndex(0) --- >>>var _a = { a: 30, b: 40 }, a = _a.a, b = _a.b; 1-> @@ -43,13 +42,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 6 > , 7 > b 8 > } = { a: 30, b: 40 }; -1->Emitted(2, 1) Source(3, 5) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 26) Source(3, 32) + SourceIndex(0) -4 >Emitted(2, 28) Source(3, 7) + SourceIndex(0) -5 >Emitted(2, 36) Source(3, 8) + SourceIndex(0) -6 >Emitted(2, 38) Source(3, 10) + SourceIndex(0) -7 >Emitted(2, 46) Source(3, 11) + SourceIndex(0) -8 >Emitted(2, 47) Source(3, 33) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 5) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 26) Source(2, 32) + SourceIndex(0) +4 >Emitted(2, 28) Source(2, 7) + SourceIndex(0) +5 >Emitted(2, 36) Source(2, 8) + SourceIndex(0) +6 >Emitted(2, 38) Source(2, 10) + SourceIndex(0) +7 >Emitted(2, 46) Source(2, 11) + SourceIndex(0) +8 >Emitted(2, 47) Source(2, 33) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols index 4fa80ecf05e..6282df94ccf 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts === - var {x} = { x: 20 }; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 5)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 11)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 0, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 0, 11)) var { a, b } = { a: 30, b: 40 }; ->a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 5)) ->b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 8)) ->a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 16)) ->b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 23)) +>a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 5)) +>b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 8)) +>a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 16)) +>b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 23)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types index 52a5484052c..f83ac86a736 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts === - var {x} = { x: 20 }; >x : number >{ x: 20 } : { x: number; } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js index f146e4bb8a7..88a5bce4dcc 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts] - var {x = 500} = { x: 20 }; //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map index 3bc06d2dc75..1faa8f8e71a 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts"],"names":[],"mappings":"AACK,IAAA,gBAAO,EAAP,4BAAO,CAAc"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts"],"names":[],"mappings":"AAAK,IAAA,gBAAO,EAAP,4BAAO,CAAc"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt index fb3483829c6..d58e756de42 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt @@ -16,18 +16,17 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var { +1 >var { 2 > 3 > x = 500 4 > 5 > x = 500 6 > } = { x: 20 }; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 21) Source(2, 13) + SourceIndex(0) -4 >Emitted(1, 23) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 51) Source(2, 13) + SourceIndex(0) -6 >Emitted(1, 52) Source(2, 27) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 21) Source(1, 13) + SourceIndex(0) +4 >Emitted(1, 23) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 51) Source(1, 13) + SourceIndex(0) +6 >Emitted(1, 52) Source(1, 27) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols index a668ab8e733..15899184e19 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts === - var {x = 500} = { x: 20 }; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 1, 5)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 1, 17)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 0, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 0, 17)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types index 4b70fa8aa8d..c4ad284f293 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts === - var {x = 500} = { x: 20 }; >x : number >500 : 500 diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js index d785d2dd1fd..3b74d1b7535 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts] - var {x = 500, y} = { x: 20, y: "hi" }; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map index 5f160d2ac45..2b6cd16157d 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts"],"names":[],"mappings":"AACI,IAAA,uBACwB,EADvB,SAAO,EAAP,4BAAO,EACP,QAAC,CAAuB"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts"],"names":[],"mappings":"AAAI,IAAA,uBACwB,EADvB,SAAO,EAAP,4BAAO,EACP,QAAC,CAAuB"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt index 6a64ae9c320..68d24cb1b32 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt @@ -20,8 +20,7 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 9 > ^^^^^^^^ 10> ^ 11> ^^^^^^^^^^^^^^^^^^-> -1 > - >var +1 >var 2 > 3 > {x = 500, > y} = { x: 20, y: "hi" } @@ -33,15 +32,15 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern > 9 > y 10> } = { x: 20, y: "hi" }; -1 >Emitted(1, 1) Source(2, 5) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 28) Source(3, 29) + SourceIndex(0) -4 >Emitted(1, 30) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 39) Source(2, 13) + SourceIndex(0) -6 >Emitted(1, 41) Source(2, 6) + SourceIndex(0) -7 >Emitted(1, 69) Source(2, 13) + SourceIndex(0) -8 >Emitted(1, 71) Source(3, 6) + SourceIndex(0) -9 >Emitted(1, 79) Source(3, 7) + SourceIndex(0) -10>Emitted(1, 80) Source(3, 30) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 5) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 28) Source(2, 29) + SourceIndex(0) +4 >Emitted(1, 30) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 39) Source(1, 13) + SourceIndex(0) +6 >Emitted(1, 41) Source(1, 6) + SourceIndex(0) +7 >Emitted(1, 69) Source(1, 13) + SourceIndex(0) +8 >Emitted(1, 71) Source(2, 6) + SourceIndex(0) +9 >Emitted(1, 79) Source(2, 7) + SourceIndex(0) +10>Emitted(1, 80) Source(2, 30) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols index 8404c342c0b..bce2734b093 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts === - var {x = 500, ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 0, 5)) y} = { x: 20, y: "hi" }; ->y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 13)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 2, 11)) ->y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 2, 18)) +>y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 0, 13)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 11)) +>y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 18)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types index 1bd508ef2e5..3952961897d 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts === - var {x = 500, >x : number >500 : 500 diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js b/tests/baselines/reference/sourceMapValidationLabeled.js index 50669b870ab..7aabc47ea4e 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.js +++ b/tests/baselines/reference/sourceMapValidationLabeled.js @@ -1,5 +1,4 @@ //// [sourceMapValidationLabeled.ts] - x: var b = 10; diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js.map b/tests/baselines/reference/sourceMapValidationLabeled.js.map index 206ac95b951..d1219f9896f 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.js.map +++ b/tests/baselines/reference/sourceMapValidationLabeled.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationLabeled.js.map] -{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AACA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AAAA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt index 7cf1bf896ca..007208c78f9 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt @@ -18,8 +18,7 @@ sourceFile:sourceMapValidationLabeled.ts 7 > ^^ 8 > ^ 9 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >x 3 > : > @@ -28,13 +27,13 @@ sourceFile:sourceMapValidationLabeled.ts 6 > = 7 > 10 8 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 2) Source(2, 2) + SourceIndex(0) -3 >Emitted(1, 4) Source(3, 1) + SourceIndex(0) -4 >Emitted(1, 8) Source(3, 5) + SourceIndex(0) -5 >Emitted(1, 9) Source(3, 6) + SourceIndex(0) -6 >Emitted(1, 12) Source(3, 9) + SourceIndex(0) -7 >Emitted(1, 14) Source(3, 11) + SourceIndex(0) -8 >Emitted(1, 15) Source(3, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 2) Source(1, 2) + SourceIndex(0) +3 >Emitted(1, 4) Source(2, 1) + SourceIndex(0) +4 >Emitted(1, 8) Source(2, 5) + SourceIndex(0) +5 >Emitted(1, 9) Source(2, 6) + SourceIndex(0) +6 >Emitted(1, 12) Source(2, 9) + SourceIndex(0) +7 >Emitted(1, 14) Source(2, 11) + SourceIndex(0) +8 >Emitted(1, 15) Source(2, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationLabeled.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationLabeled.symbols b/tests/baselines/reference/sourceMapValidationLabeled.symbols index bf9abc593b3..2a3c4f5606c 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.symbols +++ b/tests/baselines/reference/sourceMapValidationLabeled.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationLabeled.ts === - x: var b = 10; ->b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 2, 3)) +>b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 1, 3)) diff --git a/tests/baselines/reference/sourceMapValidationLabeled.types b/tests/baselines/reference/sourceMapValidationLabeled.types index 6756494a5c7..a3685eedba1 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.types +++ b/tests/baselines/reference/sourceMapValidationLabeled.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationLabeled.ts === - x: >x : any diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.js b/tests/baselines/reference/specializationsShouldNotAffectEachOther.js index 3116571166f..06370fbd450 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.js +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.js @@ -1,5 +1,4 @@ //// [specializationsShouldNotAffectEachOther.ts] - interface Series { data: string[]; } diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols index 7d5a6d979b3..a0a1dbb30d4 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols @@ -1,44 +1,43 @@ === tests/cases/compiler/specializationsShouldNotAffectEachOther.ts === - interface Series { >Series : Symbol(Series, Decl(specializationsShouldNotAffectEachOther.ts, 0, 0)) data: string[]; ->data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) +>data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19)) } var series: Series; ->series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3)) +>series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 4, 3)) >Series : Symbol(Series, Decl(specializationsShouldNotAffectEachOther.ts, 0, 0)) function foo() { ->foo : Symbol(foo, Decl(specializationsShouldNotAffectEachOther.ts, 5, 19)) +>foo : Symbol(foo, Decl(specializationsShouldNotAffectEachOther.ts, 4, 19)) var seriesExtent = (series) => null; ->seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7)) ->series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 10, 24)) +>seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 9, 7)) +>series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 9, 24)) var series2: number[]; ->series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) +>series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 11, 7)) series2.map(seriesExtent); >series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) +>series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 11, 7)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7)) +>seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 9, 7)) return null; } var keyExtent2: any[] = series.data.map(function (d: string) { return d; }); ->keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 19, 3)) +>keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 18, 3)) >series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) ->series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3)) ->data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) +>series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19)) +>series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 4, 3)) +>data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) ->d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) +>d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 18, 50)) +>d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 18, 50)) diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types index aa14eca0508..916d30fe27a 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types @@ -1,5 +1,4 @@ === tests/cases/compiler/specializationsShouldNotAffectEachOther.ts === - interface Series { >Series : Series diff --git a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt index 73318e782a3..0e9454b9018 100644 --- a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt +++ b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts(2,10): error TS2394: Overload signature is not compatible with function implementation. +tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts(1,10): error TS2394: Overload signature is not compatible with function implementation. ==== tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts (1 errors) ==== - function foo(x: 'a'); ~~~ !!! error TS2394: Overload signature is not compatible with function implementation. diff --git a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js index bb2dab55957..2654049a323 100644 --- a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js +++ b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js @@ -1,5 +1,4 @@ //// [specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts] - function foo(x: 'a'); function foo(x: number) { } diff --git a/tests/baselines/reference/spreadUnion2.js b/tests/baselines/reference/spreadUnion2.js index 6c7527af9dd..b98046463c3 100644 --- a/tests/baselines/reference/spreadUnion2.js +++ b/tests/baselines/reference/spreadUnion2.js @@ -1,5 +1,4 @@ //// [spreadUnion2.ts] - declare const undefinedUnion: { a: number } | undefined; declare const nullUnion: { b: number } | null; declare const nullAndUndefinedUnion: null | undefined; diff --git a/tests/baselines/reference/spreadUnion2.symbols b/tests/baselines/reference/spreadUnion2.symbols index cc2c194f2a6..05703fc32bd 100644 --- a/tests/baselines/reference/spreadUnion2.symbols +++ b/tests/baselines/reference/spreadUnion2.symbols @@ -1,74 +1,73 @@ === tests/cases/compiler/spreadUnion2.ts === - declare const undefinedUnion: { a: number } | undefined; ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) ->a : Symbol(a, Decl(spreadUnion2.ts, 1, 31)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) +>a : Symbol(a, Decl(spreadUnion2.ts, 0, 31)) declare const nullUnion: { b: number } | null; ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) ->b : Symbol(b, Decl(spreadUnion2.ts, 2, 26)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) +>b : Symbol(b, Decl(spreadUnion2.ts, 1, 26)) declare const nullAndUndefinedUnion: null | undefined; ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) var o1: { a: number }; ->o1 : Symbol(o1, Decl(spreadUnion2.ts, 5, 3), Decl(spreadUnion2.ts, 6, 3)) ->a : Symbol(a, Decl(spreadUnion2.ts, 5, 9)) +>o1 : Symbol(o1, Decl(spreadUnion2.ts, 4, 3), Decl(spreadUnion2.ts, 5, 3)) +>a : Symbol(a, Decl(spreadUnion2.ts, 4, 9)) var o1 = { ...undefinedUnion }; ->o1 : Symbol(o1, Decl(spreadUnion2.ts, 5, 3), Decl(spreadUnion2.ts, 6, 3)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) +>o1 : Symbol(o1, Decl(spreadUnion2.ts, 4, 3), Decl(spreadUnion2.ts, 5, 3)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) var o2: { b: number }; ->o2 : Symbol(o2, Decl(spreadUnion2.ts, 8, 3), Decl(spreadUnion2.ts, 9, 3)) ->b : Symbol(b, Decl(spreadUnion2.ts, 8, 9)) +>o2 : Symbol(o2, Decl(spreadUnion2.ts, 7, 3), Decl(spreadUnion2.ts, 8, 3)) +>b : Symbol(b, Decl(spreadUnion2.ts, 7, 9)) var o2 = { ...nullUnion }; ->o2 : Symbol(o2, Decl(spreadUnion2.ts, 8, 3), Decl(spreadUnion2.ts, 9, 3)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) +>o2 : Symbol(o2, Decl(spreadUnion2.ts, 7, 3), Decl(spreadUnion2.ts, 8, 3)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) var o3: { a: number, b: number }; ->o3 : Symbol(o3, Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3), Decl(spreadUnion2.ts, 13, 3)) ->a : Symbol(a, Decl(spreadUnion2.ts, 11, 9)) ->b : Symbol(b, Decl(spreadUnion2.ts, 11, 20)) +>o3 : Symbol(o3, Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3)) +>a : Symbol(a, Decl(spreadUnion2.ts, 10, 9)) +>b : Symbol(b, Decl(spreadUnion2.ts, 10, 20)) var o3 = { ...undefinedUnion, ...nullUnion }; ->o3 : Symbol(o3, Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3), Decl(spreadUnion2.ts, 13, 3)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) +>o3 : Symbol(o3, Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) var o3 = { ...nullUnion, ...undefinedUnion }; ->o3 : Symbol(o3, Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3), Decl(spreadUnion2.ts, 13, 3)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) +>o3 : Symbol(o3, Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) var o4: { a: number }; ->o4 : Symbol(o4, Decl(spreadUnion2.ts, 15, 3), Decl(spreadUnion2.ts, 16, 3)) ->a : Symbol(a, Decl(spreadUnion2.ts, 15, 9)) +>o4 : Symbol(o4, Decl(spreadUnion2.ts, 14, 3), Decl(spreadUnion2.ts, 15, 3)) +>a : Symbol(a, Decl(spreadUnion2.ts, 14, 9)) var o4 = { ...undefinedUnion, ...undefinedUnion }; ->o4 : Symbol(o4, Decl(spreadUnion2.ts, 15, 3), Decl(spreadUnion2.ts, 16, 3)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) +>o4 : Symbol(o4, Decl(spreadUnion2.ts, 14, 3), Decl(spreadUnion2.ts, 15, 3)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) var o5: { b: number }; ->o5 : Symbol(o5, Decl(spreadUnion2.ts, 18, 3), Decl(spreadUnion2.ts, 19, 3)) ->b : Symbol(b, Decl(spreadUnion2.ts, 18, 9)) +>o5 : Symbol(o5, Decl(spreadUnion2.ts, 17, 3), Decl(spreadUnion2.ts, 18, 3)) +>b : Symbol(b, Decl(spreadUnion2.ts, 17, 9)) var o5 = { ...nullUnion, ...nullUnion }; ->o5 : Symbol(o5, Decl(spreadUnion2.ts, 18, 3), Decl(spreadUnion2.ts, 19, 3)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) +>o5 : Symbol(o5, Decl(spreadUnion2.ts, 17, 3), Decl(spreadUnion2.ts, 18, 3)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) var o6: { }; ->o6 : Symbol(o6, Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3), Decl(spreadUnion2.ts, 23, 3)) +>o6 : Symbol(o6, Decl(spreadUnion2.ts, 20, 3), Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3)) var o6 = { ...nullAndUndefinedUnion, ...nullAndUndefinedUnion }; ->o6 : Symbol(o6, Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3), Decl(spreadUnion2.ts, 23, 3)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) +>o6 : Symbol(o6, Decl(spreadUnion2.ts, 20, 3), Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) var o6 = { ...nullAndUndefinedUnion }; ->o6 : Symbol(o6, Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3), Decl(spreadUnion2.ts, 23, 3)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) +>o6 : Symbol(o6, Decl(spreadUnion2.ts, 20, 3), Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) diff --git a/tests/baselines/reference/spreadUnion2.types b/tests/baselines/reference/spreadUnion2.types index cf90381ca77..97fbb9838c7 100644 --- a/tests/baselines/reference/spreadUnion2.types +++ b/tests/baselines/reference/spreadUnion2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/spreadUnion2.ts === - declare const undefinedUnion: { a: number } | undefined; >undefinedUnion : { a: number; } | undefined >a : number diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols index 46297eab86a..bafb805fb19 100644 --- a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols +++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols @@ -1,107 +1,106 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts === - // name declare class StaticName { >StaticName : Symbol(StaticName, Decl(decl.d.ts, 0, 0)) static name: number; // ok ->name : Symbol(StaticName.name, Decl(decl.d.ts, 2, 26)) +>name : Symbol(StaticName.name, Decl(decl.d.ts, 1, 26)) name: string; // ok ->name : Symbol(StaticName.name, Decl(decl.d.ts, 3, 24)) +>name : Symbol(StaticName.name, Decl(decl.d.ts, 2, 24)) } declare class StaticNameFn { ->StaticNameFn : Symbol(StaticNameFn, Decl(decl.d.ts, 5, 1)) +>StaticNameFn : Symbol(StaticNameFn, Decl(decl.d.ts, 4, 1)) static name(): string; // ok ->name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 7, 28)) +>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 6, 28)) name(): string; // ok ->name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 8, 26)) +>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 7, 26)) } // length declare class StaticLength { ->StaticLength : Symbol(StaticLength, Decl(decl.d.ts, 10, 1)) +>StaticLength : Symbol(StaticLength, Decl(decl.d.ts, 9, 1)) static length: number; // ok ->length : Symbol(StaticLength.length, Decl(decl.d.ts, 13, 28)) +>length : Symbol(StaticLength.length, Decl(decl.d.ts, 12, 28)) length: string; // ok ->length : Symbol(StaticLength.length, Decl(decl.d.ts, 14, 26)) +>length : Symbol(StaticLength.length, Decl(decl.d.ts, 13, 26)) } declare class StaticLengthFn { ->StaticLengthFn : Symbol(StaticLengthFn, Decl(decl.d.ts, 16, 1)) +>StaticLengthFn : Symbol(StaticLengthFn, Decl(decl.d.ts, 15, 1)) static length(): number; // ok ->length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 18, 30)) +>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 17, 30)) length(): number; // ok ->length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 19, 28)) +>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 18, 28)) } // prototype declare class StaticPrototype { ->StaticPrototype : Symbol(StaticPrototype, Decl(decl.d.ts, 21, 1)) +>StaticPrototype : Symbol(StaticPrototype, Decl(decl.d.ts, 20, 1)) static prototype: number; // ok ->prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 24, 31)) +>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 23, 31)) prototype: string; // ok ->prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 25, 29)) +>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 24, 29)) } declare class StaticPrototypeFn { ->StaticPrototypeFn : Symbol(StaticPrototypeFn, Decl(decl.d.ts, 27, 1)) +>StaticPrototypeFn : Symbol(StaticPrototypeFn, Decl(decl.d.ts, 26, 1)) static prototype: any; // ok ->prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 29, 33)) +>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 28, 33)) prototype(): any; // ok ->prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 30, 26)) +>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 29, 26)) } // caller declare class StaticCaller { ->StaticCaller : Symbol(StaticCaller, Decl(decl.d.ts, 32, 1)) +>StaticCaller : Symbol(StaticCaller, Decl(decl.d.ts, 31, 1)) static caller: number; // ok ->caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 35, 28)) +>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 34, 28)) caller: string; // ok ->caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 36, 26)) +>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 35, 26)) } declare class StaticCallerFn { ->StaticCallerFn : Symbol(StaticCallerFn, Decl(decl.d.ts, 38, 1)) +>StaticCallerFn : Symbol(StaticCallerFn, Decl(decl.d.ts, 37, 1)) static caller(): any; // ok ->caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 40, 30)) +>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 39, 30)) caller(): any; // ok ->caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 41, 25)) +>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 40, 25)) } // arguments declare class StaticArguments { ->StaticArguments : Symbol(StaticArguments, Decl(decl.d.ts, 43, 1)) +>StaticArguments : Symbol(StaticArguments, Decl(decl.d.ts, 42, 1)) static arguments: number; // ok ->arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 46, 31)) +>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 45, 31)) arguments: string; // ok ->arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 47, 29)) +>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 46, 29)) } declare class StaticArgumentsFn { ->StaticArgumentsFn : Symbol(StaticArgumentsFn, Decl(decl.d.ts, 49, 1)) +>StaticArgumentsFn : Symbol(StaticArgumentsFn, Decl(decl.d.ts, 48, 1)) static arguments(): any; // ok ->arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 51, 33)) +>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 50, 33)) arguments(): any; // ok ->arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 52, 28)) +>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 51, 28)) } diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types index 233bd8a46fc..31a5ea0fc3c 100644 --- a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types +++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts === - // name declare class StaticName { >StaticName : StaticName diff --git a/tests/baselines/reference/staticVisibility.errors.txt b/tests/baselines/reference/staticVisibility.errors.txt index a92cb7f88cd..43691d2744f 100644 --- a/tests/baselines/reference/staticVisibility.errors.txt +++ b/tests/baselines/reference/staticVisibility.errors.txt @@ -1,14 +1,13 @@ -tests/cases/compiler/staticVisibility.ts(10,9): error TS2662: Cannot find name 's'. Did you mean the static member 'C1.s'? -tests/cases/compiler/staticVisibility.ts(13,9): error TS2662: Cannot find name 'b'. Did you mean the static member 'C1.b'? -tests/cases/compiler/staticVisibility.ts(18,9): error TS2304: Cannot find name 'v'. -tests/cases/compiler/staticVisibility.ts(19,14): error TS2339: Property 'p' does not exist on type 'typeof C1'. -tests/cases/compiler/staticVisibility.ts(31,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/staticVisibility.ts(33,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/staticVisibility.ts(33,29): error TS2304: Cannot find name 'barback'. +tests/cases/compiler/staticVisibility.ts(9,9): error TS2662: Cannot find name 's'. Did you mean the static member 'C1.s'? +tests/cases/compiler/staticVisibility.ts(12,9): error TS2662: Cannot find name 'b'. Did you mean the static member 'C1.b'? +tests/cases/compiler/staticVisibility.ts(17,9): error TS2304: Cannot find name 'v'. +tests/cases/compiler/staticVisibility.ts(18,14): error TS2339: Property 'p' does not exist on type 'typeof C1'. +tests/cases/compiler/staticVisibility.ts(30,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/staticVisibility.ts(32,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/staticVisibility.ts(32,29): error TS2304: Cannot find name 'barback'. ==== tests/cases/compiler/staticVisibility.ts (7 errors) ==== - class C1 { p: any; diff --git a/tests/baselines/reference/staticVisibility.js b/tests/baselines/reference/staticVisibility.js index fd0a3ba52b0..60047c9c050 100644 --- a/tests/baselines/reference/staticVisibility.js +++ b/tests/baselines/reference/staticVisibility.js @@ -1,5 +1,4 @@ //// [staticVisibility.ts] - class C1 { p: any; diff --git a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt index 3405db573a9..bde4ec862bd 100644 --- a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt +++ b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(3,8): error TS1214: Identifier expected. 'public' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(3,25): error TS2307: Cannot find module '1'. +tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(2,8): error TS1214: Identifier expected. 'public' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(2,25): error TS2307: Cannot find module '1'. ==== tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts (2 errors) ==== - "use strict" import public = require("1"); ~~~~~~ diff --git a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js index 409e6f67584..16e8580e727 100644 --- a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js +++ b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js @@ -1,5 +1,4 @@ //// [strictModeReservedWordInImportEqualDeclaration.ts] - "use strict" import public = require("1"); diff --git a/tests/baselines/reference/strictNullChecksNoWidening.js b/tests/baselines/reference/strictNullChecksNoWidening.js index ba26a04fc13..72922d93f02 100644 --- a/tests/baselines/reference/strictNullChecksNoWidening.js +++ b/tests/baselines/reference/strictNullChecksNoWidening.js @@ -1,5 +1,4 @@ //// [strictNullChecksNoWidening.ts] - var a1 = null; var a2 = undefined; var a3 = void 0; diff --git a/tests/baselines/reference/strictNullChecksNoWidening.symbols b/tests/baselines/reference/strictNullChecksNoWidening.symbols index a23a0d2e926..415ce613eb2 100644 --- a/tests/baselines/reference/strictNullChecksNoWidening.symbols +++ b/tests/baselines/reference/strictNullChecksNoWidening.symbols @@ -1,48 +1,47 @@ === tests/cases/conformance/types/typeRelationships/widenedTypes/strictNullChecksNoWidening.ts === - var a1 = null; ->a1 : Symbol(a1, Decl(strictNullChecksNoWidening.ts, 1, 3)) +>a1 : Symbol(a1, Decl(strictNullChecksNoWidening.ts, 0, 3)) var a2 = undefined; ->a2 : Symbol(a2, Decl(strictNullChecksNoWidening.ts, 2, 3)) +>a2 : Symbol(a2, Decl(strictNullChecksNoWidening.ts, 1, 3)) >undefined : Symbol(undefined) var a3 = void 0; ->a3 : Symbol(a3, Decl(strictNullChecksNoWidening.ts, 3, 3)) +>a3 : Symbol(a3, Decl(strictNullChecksNoWidening.ts, 2, 3)) var b1 = []; ->b1 : Symbol(b1, Decl(strictNullChecksNoWidening.ts, 5, 3)) +>b1 : Symbol(b1, Decl(strictNullChecksNoWidening.ts, 4, 3)) var b2 = [,]; ->b2 : Symbol(b2, Decl(strictNullChecksNoWidening.ts, 6, 3)) +>b2 : Symbol(b2, Decl(strictNullChecksNoWidening.ts, 5, 3)) var b3 = [undefined]; ->b3 : Symbol(b3, Decl(strictNullChecksNoWidening.ts, 7, 3)) +>b3 : Symbol(b3, Decl(strictNullChecksNoWidening.ts, 6, 3)) >undefined : Symbol(undefined) var b4 = [[], []]; ->b4 : Symbol(b4, Decl(strictNullChecksNoWidening.ts, 8, 3)) +>b4 : Symbol(b4, Decl(strictNullChecksNoWidening.ts, 7, 3)) var b5 = [[], [,]]; ->b5 : Symbol(b5, Decl(strictNullChecksNoWidening.ts, 9, 3)) +>b5 : Symbol(b5, Decl(strictNullChecksNoWidening.ts, 8, 3)) declare function f(x: T): T; ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) ->T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 11, 19)) ->x : Symbol(x, Decl(strictNullChecksNoWidening.ts, 11, 22)) ->T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 11, 19)) ->T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 11, 19)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) +>T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 10, 19)) +>x : Symbol(x, Decl(strictNullChecksNoWidening.ts, 10, 22)) +>T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 10, 19)) +>T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 10, 19)) var c1 = f(null); ->c1 : Symbol(c1, Decl(strictNullChecksNoWidening.ts, 13, 3)) ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) +>c1 : Symbol(c1, Decl(strictNullChecksNoWidening.ts, 12, 3)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) var c2 = f(undefined); ->c2 : Symbol(c2, Decl(strictNullChecksNoWidening.ts, 14, 3)) ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) +>c2 : Symbol(c2, Decl(strictNullChecksNoWidening.ts, 13, 3)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) >undefined : Symbol(undefined) var c3 = f([]); ->c3 : Symbol(c3, Decl(strictNullChecksNoWidening.ts, 15, 3)) ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) +>c3 : Symbol(c3, Decl(strictNullChecksNoWidening.ts, 14, 3)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) diff --git a/tests/baselines/reference/strictNullChecksNoWidening.types b/tests/baselines/reference/strictNullChecksNoWidening.types index a544f9cef94..ec4141b1018 100644 --- a/tests/baselines/reference/strictNullChecksNoWidening.types +++ b/tests/baselines/reference/strictNullChecksNoWidening.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/widenedTypes/strictNullChecksNoWidening.ts === - var a1 = null; >a1 : null >null : null diff --git a/tests/baselines/reference/strictNullLogicalAndOr.js b/tests/baselines/reference/strictNullLogicalAndOr.js index f4dafe334b5..1b2d6d384e6 100644 --- a/tests/baselines/reference/strictNullLogicalAndOr.js +++ b/tests/baselines/reference/strictNullLogicalAndOr.js @@ -1,5 +1,4 @@ //// [strictNullLogicalAndOr.ts] - // Repro from #9113 let sinOrCos = Math.random() < .5; diff --git a/tests/baselines/reference/strictNullLogicalAndOr.symbols b/tests/baselines/reference/strictNullLogicalAndOr.symbols index 8bb0343b9c0..3dea02e8e8b 100644 --- a/tests/baselines/reference/strictNullLogicalAndOr.symbols +++ b/tests/baselines/reference/strictNullLogicalAndOr.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/strictNullLogicalAndOr.ts === - // Repro from #9113 let sinOrCos = Math.random() < .5; ->sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 3, 3)) +>sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 2, 3)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) let choice = sinOrCos && Math.sin || Math.cos; ->choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 4, 3)) ->sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 3, 3)) +>choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 3, 3)) +>sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 2, 3)) >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) @@ -19,26 +18,26 @@ let choice = sinOrCos && Math.sin || Math.cos; >cos : Symbol(Math.cos, Decl(lib.d.ts, --, --)) choice(Math.PI); ->choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 4, 3)) +>choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 3, 3)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) function sq(n?: number): number { ->sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 6, 16)) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) +>sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 5, 16)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) const r = n !== undefined && n*n || 0; ->r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 9, 7)) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) +>r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 8, 7)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) return r; ->r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 9, 7)) +>r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 8, 7)) } sq(3); ->sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 6, 16)) +>sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 5, 16)) diff --git a/tests/baselines/reference/strictNullLogicalAndOr.types b/tests/baselines/reference/strictNullLogicalAndOr.types index 50eb6586a0f..33881b5d9d7 100644 --- a/tests/baselines/reference/strictNullLogicalAndOr.types +++ b/tests/baselines/reference/strictNullLogicalAndOr.types @@ -1,5 +1,4 @@ === tests/cases/compiler/strictNullLogicalAndOr.ts === - // Repro from #9113 let sinOrCos = Math.random() < .5; diff --git a/tests/baselines/reference/stringIncludes.js b/tests/baselines/reference/stringIncludes.js index 055d7d8beeb..e5c2d20ae56 100644 --- a/tests/baselines/reference/stringIncludes.js +++ b/tests/baselines/reference/stringIncludes.js @@ -1,5 +1,4 @@ //// [stringIncludes.ts] - var includes: boolean; includes = "abcde".includes("cd"); includes = "abcde".includes("cd", 2); diff --git a/tests/baselines/reference/stringIncludes.symbols b/tests/baselines/reference/stringIncludes.symbols index 5b2bf4b7afa..ba3c5ade73e 100644 --- a/tests/baselines/reference/stringIncludes.symbols +++ b/tests/baselines/reference/stringIncludes.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/stringIncludes.ts === - var includes: boolean; ->includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) +>includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3)) includes = "abcde".includes("cd"); ->includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) +>includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3)) >"abcde".includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) includes = "abcde".includes("cd", 2); ->includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) +>includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3)) >"abcde".includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) diff --git a/tests/baselines/reference/stringIncludes.types b/tests/baselines/reference/stringIncludes.types index 1dce85fcec7..c97ad7eefa3 100644 --- a/tests/baselines/reference/stringIncludes.types +++ b/tests/baselines/reference/stringIncludes.types @@ -1,5 +1,4 @@ === tests/cases/compiler/stringIncludes.ts === - var includes: boolean; >includes : boolean diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.js b/tests/baselines/reference/stringLiteralCheckedInIf01.js index 161c39b96ef..8de3a3bfc34 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf01.js +++ b/tests/baselines/reference/stringLiteralCheckedInIf01.js @@ -1,5 +1,4 @@ //// [stringLiteralCheckedInIf01.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.symbols b/tests/baselines/reference/stringLiteralCheckedInIf01.symbols index 1b4d5e6b071..c77a9b0d411 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf01.symbols +++ b/tests/baselines/reference/stringLiteralCheckedInIf01.symbols @@ -1,33 +1,32 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf01.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) function f(foo: T) { ->f : Symbol(f, Decl(stringLiteralCheckedInIf01.ts, 2, 17)) ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) ->T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 1, 19)) +>f : Symbol(f, Decl(stringLiteralCheckedInIf01.ts, 1, 17)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 0, 19)) if (foo === "a") { ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) return foo; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) } else if (foo === "b") { ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) return foo; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) } else { return (foo as S[])[0]; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) } } diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.types b/tests/baselines/reference/stringLiteralCheckedInIf01.types index 2505870f9a9..822bc569001 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf01.types +++ b/tests/baselines/reference/stringLiteralCheckedInIf01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf01.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.js b/tests/baselines/reference/stringLiteralCheckedInIf02.js index 22bd6359f61..4e9e7220ae7 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf02.js +++ b/tests/baselines/reference/stringLiteralCheckedInIf02.js @@ -1,5 +1,4 @@ //// [stringLiteralCheckedInIf02.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.symbols b/tests/baselines/reference/stringLiteralCheckedInIf02.symbols index 629f990b912..33d7e0f41cc 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf02.symbols +++ b/tests/baselines/reference/stringLiteralCheckedInIf02.symbols @@ -1,39 +1,38 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf02.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) function isS(t: T): t is S { ->isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 2, 17)) ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) ->T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 1, 19)) ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) +>isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 1, 17)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 0, 19)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) return t === "a" || t === "b"; ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) } function f(foo: T) { ->f : Symbol(f, Decl(stringLiteralCheckedInIf02.ts, 6, 1)) ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) ->T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 1, 19)) +>f : Symbol(f, Decl(stringLiteralCheckedInIf02.ts, 5, 1)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 0, 19)) if (isS(foo)) { ->isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 2, 17)) ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) +>isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 1, 17)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) return foo; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) } else { return foo[0]; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) } } diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.types b/tests/baselines/reference/stringLiteralCheckedInIf02.types index 6589c85222a..586cf101398 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf02.types +++ b/tests/baselines/reference/stringLiteralCheckedInIf02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf02.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.js b/tests/baselines/reference/stringLiteralMatchedInSwitch01.js index b9b24cf0c66..af606d03e94 100644 --- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.js +++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.js @@ -1,5 +1,4 @@ //// [stringLiteralMatchedInSwitch01.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols b/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols index 0323371c307..29ad91f0ea2 100644 --- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols +++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols @@ -1,27 +1,26 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralMatchedInSwitch01.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) var foo: T; ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) ->T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 1, 19)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) +>T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 0, 19)) switch (foo) { ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) case "a": case "b": break; default: foo = (foo as S[])[0]; ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) break; diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.types b/tests/baselines/reference/stringLiteralMatchedInSwitch01.types index 5f2d68d47cd..bbdc014040d 100644 --- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.types +++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralMatchedInSwitch01.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.js b/tests/baselines/reference/stringLiteralTypeAssertion01.js index 7877004cf01..080c19854a5 100644 --- a/tests/baselines/reference/stringLiteralTypeAssertion01.js +++ b/tests/baselines/reference/stringLiteralTypeAssertion01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypeAssertion01.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.symbols b/tests/baselines/reference/stringLiteralTypeAssertion01.symbols index 1491a32b6f8..4129be8a0e8 100644 --- a/tests/baselines/reference/stringLiteralTypeAssertion01.symbols +++ b/tests/baselines/reference/stringLiteralTypeAssertion01.symbols @@ -1,83 +1,82 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) var s: S; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) var t: T; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) var str: string; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) //////////////// s = t; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) s = t as S; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) s = str; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) s = str as S; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) //////////////// t = s; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) t = s as T; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) t = str; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) t = str as T; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) //////////////// str = s; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) str = s as string; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) str = t; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) str = t as string; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.types b/tests/baselines/reference/stringLiteralTypeAssertion01.types index 051b8ffc573..ea620ace34f 100644 --- a/tests/baselines/reference/stringLiteralTypeAssertion01.types +++ b/tests/baselines/reference/stringLiteralTypeAssertion01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt index 1596d74281a..4d870aa77b7 100644 --- a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndLogicalOrExpressions01.ts(8,5): error TS2322: Type 'string' is not assignable to type '"foo" | "bar"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndLogicalOrExpressions01.ts(7,5): error TS2322: Type 'string' is not assignable to type '"foo" | "bar"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndLogicalOrExpressions01.ts (1 errors) ==== - declare function myRandBool(): boolean; let a: "foo" = "foo"; diff --git a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js index 33dce2041e3..255121498e9 100644 --- a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js +++ b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAndLogicalOrExpressions01.ts] - declare function myRandBool(): boolean; let a: "foo" = "foo"; diff --git a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js index 1fe1225c6f4..f5bbe55aae4 100644 --- a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js +++ b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAndParenthesizedExpressions01.ts] - declare function myRandBool(): boolean; let a: "foo" = ("foo"); diff --git a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols index 2206a5185c1..98d495c8389 100644 --- a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndParenthesizedExpressions01.ts === - declare function myRandBool(): boolean; >myRandBool : Symbol(myRandBool, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 0, 0)) let a: "foo" = ("foo"); ->a : Symbol(a, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 2, 3)) let b: "foo" | "bar" = ("foo"); ->b : Symbol(b, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 3, 3)) let c: "foo" = (myRandBool ? "foo" : ("foo")); ->c : Symbol(c, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 5, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 4, 3)) >myRandBool : Symbol(myRandBool, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 0, 0)) let d: "foo" | "bar" = (myRandBool ? "foo" : ("bar")); ->d : Symbol(d, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 6, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 5, 3)) >myRandBool : Symbol(myRandBool, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 0, 0)) diff --git a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types index 0bb2e1dd3c7..0533ab39151 100644 --- a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types +++ b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndParenthesizedExpressions01.ts === - declare function myRandBool(): boolean; >myRandBool : () => boolean diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.js b/tests/baselines/reference/stringLiteralTypesAndTuples01.js index 4700cc65730..11aebfc0404 100644 --- a/tests/baselines/reference/stringLiteralTypesAndTuples01.js +++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAndTuples01.ts] - // Should all be strings. let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"]; diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols b/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols index b7ca53517ca..523cb8bafa0 100644 --- a/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols @@ -1,41 +1,40 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndTuples01.ts === - // Should all be strings. let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"]; ->hello : Symbol(hello, Decl(stringLiteralTypesAndTuples01.ts, 2, 5)) ->brave : Symbol(brave, Decl(stringLiteralTypesAndTuples01.ts, 2, 11)) ->newish : Symbol(newish, Decl(stringLiteralTypesAndTuples01.ts, 2, 18)) ->world : Symbol(world, Decl(stringLiteralTypesAndTuples01.ts, 2, 26)) +>hello : Symbol(hello, Decl(stringLiteralTypesAndTuples01.ts, 1, 5)) +>brave : Symbol(brave, Decl(stringLiteralTypesAndTuples01.ts, 1, 11)) +>newish : Symbol(newish, Decl(stringLiteralTypesAndTuples01.ts, 1, 18)) +>world : Symbol(world, Decl(stringLiteralTypesAndTuples01.ts, 1, 26)) type RexOrRaptor = "t-rex" | "raptor" ->RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 2, 71)) +>RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 1, 71)) let [im, a, dinosaur]: ["I'm", "a", RexOrRaptor] = ['I\'m', 'a', 't-rex']; ->im : Symbol(im, Decl(stringLiteralTypesAndTuples01.ts, 5, 5)) ->a : Symbol(a, Decl(stringLiteralTypesAndTuples01.ts, 5, 8)) ->dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 5, 11)) ->RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 2, 71)) +>im : Symbol(im, Decl(stringLiteralTypesAndTuples01.ts, 4, 5)) +>a : Symbol(a, Decl(stringLiteralTypesAndTuples01.ts, 4, 8)) +>dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 4, 11)) +>RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 1, 71)) rawr(dinosaur); ->rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 7, 15)) ->dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 5, 11)) +>rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 6, 15)) +>dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 4, 11)) function rawr(dino: RexOrRaptor) { ->rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 7, 15)) ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) ->RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 2, 71)) +>rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 6, 15)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) +>RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 1, 71)) if (dino === "t-rex") { ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) return "ROAAAAR!"; } if (dino === "raptor") { ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) return "yip yip!"; } throw "Unexpected " + dino; ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) } diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.types b/tests/baselines/reference/stringLiteralTypesAndTuples01.types index f69e36cf541..2adce12cd1e 100644 --- a/tests/baselines/reference/stringLiteralTypesAndTuples01.types +++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndTuples01.ts === - // Should all be strings. let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"]; >hello : string diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.js b/tests/baselines/reference/stringLiteralTypesAsTags01.js index b7b3872ce66..adecab0b1b8 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags01.js +++ b/tests/baselines/reference/stringLiteralTypesAsTags01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTags01.ts] - type Kind = "A" | "B" interface Entity { diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.symbols b/tests/baselines/reference/stringLiteralTypesAsTags01.symbols index f092e1f7a50..9f97836f5b6 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTags01.symbols @@ -1,112 +1,111 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) interface Entity { ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) kind: Kind; ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 2, 18)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) } interface A extends Entity { ->A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 4, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) kind: "A"; ->kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags01.ts, 7, 28)) +>kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags01.ts, 6, 28)) a: number; ->a : Symbol(A.a, Decl(stringLiteralTypesAsTags01.ts, 8, 14)) +>a : Symbol(A.a, Decl(stringLiteralTypesAsTags01.ts, 7, 14)) } interface B extends Entity { ->B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 10, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 9, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) kind: "B"; ->kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags01.ts, 12, 28)) +>kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags01.ts, 11, 28)) b: string; ->b : Symbol(B.b, Decl(stringLiteralTypesAsTags01.ts, 13, 14)) +>b : Symbol(B.b, Decl(stringLiteralTypesAsTags01.ts, 12, 14)) } function hasKind(entity: Entity, kind: "A"): entity is A; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 17, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 16, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 16, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 16, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 4, 1)) function hasKind(entity: Entity, kind: "B"): entity is B; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 18, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 10, 1)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 17, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 9, 1)) function hasKind(entity: Entity, kind: Kind): entity is Entity; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 19, 32)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 18, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) function hasKind(entity: Entity, kind: Kind): boolean { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 20, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 20, 32)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 19, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) return entity.kind === kind; ->entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 20, 17)) ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 20, 32)) +>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 2, 18)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 2, 18)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 19, 32)) } let x: A = { ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 4, 1)) kind: "A", ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 24, 12)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 23, 12)) a: 100, ->a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 25, 14)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 24, 14)) } if (hasKind(x, "A")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 30, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 29, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesAsTags01.ts, 33, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAsTags01.ts, 32, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } if (!hasKind(x, "B")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesAsTags01.ts, 37, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAsTags01.ts, 36, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesAsTags01.ts, 40, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAsTags01.ts, 39, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.types b/tests/baselines/reference/stringLiteralTypesAsTags01.types index ad53fb01c79..6caf851a726 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags01.types +++ b/tests/baselines/reference/stringLiteralTypesAsTags01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.js b/tests/baselines/reference/stringLiteralTypesAsTags02.js index e83f1ad46ee..299686b0802 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags02.js +++ b/tests/baselines/reference/stringLiteralTypesAsTags02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTags02.ts] - type Kind = "A" | "B" interface Entity { diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.symbols b/tests/baselines/reference/stringLiteralTypesAsTags02.symbols index 1cf73015ea7..8cc3de5fc74 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags02.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTags02.symbols @@ -1,106 +1,105 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags02.ts, 0, 0)) interface Entity { ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) kind: Kind; ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 3, 18)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 2, 18)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags02.ts, 0, 0)) } interface A extends Entity { ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) kind: "A"; ->kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags02.ts, 7, 28)) +>kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags02.ts, 6, 28)) a: number; ->a : Symbol(A.a, Decl(stringLiteralTypesAsTags02.ts, 8, 14)) +>a : Symbol(A.a, Decl(stringLiteralTypesAsTags02.ts, 7, 14)) } interface B extends Entity { ->B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 10, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 9, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) kind: "B"; ->kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags02.ts, 12, 28)) +>kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags02.ts, 11, 28)) b: string; ->b : Symbol(B.b, Decl(stringLiteralTypesAsTags02.ts, 13, 14)) +>b : Symbol(B.b, Decl(stringLiteralTypesAsTags02.ts, 12, 14)) } function hasKind(entity: Entity, kind: "A"): entity is A; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 17, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 17, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 17, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 16, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 16, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 16, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) function hasKind(entity: Entity, kind: "B"): entity is B; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 18, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 10, 1)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 17, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 17, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 17, 17)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 9, 1)) function hasKind(entity: Entity, kind: Kind): entity is (A | B) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 19, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 19, 32)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 18, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags02.ts, 0, 0)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 19, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 10, 1)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 9, 1)) return entity.kind === kind; ->entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 3, 18)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 19, 17)) ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 3, 18)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 19, 32)) +>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 2, 18)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 2, 18)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 18, 32)) } let x: A = { ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) kind: "A", ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 23, 12)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 22, 12)) a: 100, ->a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 24, 14)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 23, 14)) } if (hasKind(x, "A")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 29, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 28, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesAsTags02.ts, 32, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAsTags02.ts, 31, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } if (!hasKind(x, "B")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesAsTags02.ts, 36, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAsTags02.ts, 35, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesAsTags02.ts, 39, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAsTags02.ts, 38, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.types b/tests/baselines/reference/stringLiteralTypesAsTags02.types index 2e2cb2831b6..f90ea6c6a06 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags02.types +++ b/tests/baselines/reference/stringLiteralTypesAsTags02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.js b/tests/baselines/reference/stringLiteralTypesAsTags03.js index bb2ed56040e..761037dda2d 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags03.js +++ b/tests/baselines/reference/stringLiteralTypesAsTags03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTags03.ts] - type Kind = "A" | "B" interface Entity { diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.symbols b/tests/baselines/reference/stringLiteralTypesAsTags03.symbols index 6f7e522d55b..b76619e8e91 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags03.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTags03.symbols @@ -1,36 +1,35 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0)) interface Entity { ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) kind: Kind; ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 2, 18)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0)) } interface A extends Entity { ->A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 4, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) kind: "A"; ->kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags03.ts, 7, 28)) +>kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags03.ts, 6, 28)) a: number; ->a : Symbol(A.a, Decl(stringLiteralTypesAsTags03.ts, 8, 14)) +>a : Symbol(A.a, Decl(stringLiteralTypesAsTags03.ts, 7, 14)) } interface B extends Entity { ->B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 10, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 9, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) kind: "B"; ->kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags03.ts, 12, 28)) +>kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags03.ts, 11, 28)) b: string; ->b : Symbol(B.b, Decl(stringLiteralTypesAsTags03.ts, 13, 14)) +>b : Symbol(B.b, Decl(stringLiteralTypesAsTags03.ts, 12, 14)) } // Currently (2015-12-14), we write '"A" | "A"' and '"B" | "B"' to avoid @@ -38,72 +37,72 @@ interface B extends Entity { // That way, we can avoid the need to look for a compatible overload // signature and simply check compatibility with the implementation. function hasKind(entity: Entity, kind: "A" | "A"): entity is A; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 21, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 20, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 20, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 20, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 4, 1)) function hasKind(entity: Entity, kind: "B" | "B"): entity is B; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 22, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 10, 1)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 21, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 9, 1)) function hasKind(entity: Entity, kind: Kind): entity is Entity { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 23, 32)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 22, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) return entity.kind === kind; ->entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17)) ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 23, 32)) +>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 2, 18)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 2, 18)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 22, 32)) } let x: A = { ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 4, 1)) kind: "A", ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 27, 12)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 26, 12)) a: 100, ->a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 28, 14)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 27, 14)) } if (hasKind(x, "A")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 33, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 32, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesAsTags03.ts, 36, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAsTags03.ts, 35, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } if (!hasKind(x, "B")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesAsTags03.ts, 40, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAsTags03.ts, 39, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesAsTags03.ts, 43, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAsTags03.ts, 42, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.types b/tests/baselines/reference/stringLiteralTypesAsTags03.types index 17507c1036f..64622e28ac8 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags03.types +++ b/tests/baselines/reference/stringLiteralTypesAsTags03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js index 4f49d326ec0..018f6a0d415 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTypeParameterConstraint01.ts] - function foo(f: (x: T) => T) { return f; } diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols index fd633b6e4d9..11f02a638ae 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols @@ -1,60 +1,59 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint01.ts === - function foo(f: (x: T) => T) { >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 0)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 13)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 30)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 34)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 13)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 13)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 30)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 34)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 13)) return f; ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 30)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 30)) } function bar(f: (x: T) => T) { ->bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 3, 1)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 13)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 38)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 42)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 13)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 13)) +>bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 2, 1)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 13)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 38)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 42)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 13)) return f; ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 38)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 38)) } let f = foo(x => x); ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 3)) >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 0)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 12)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 12)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 12)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 12)) let fResult = f("foo"); ->fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 10, 3)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 3)) +>fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 3)) let g = foo((x => x)); ->g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 3)) +>g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 3)) >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 0)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 13)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 13)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 13)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 13)) let gResult = g("foo"); ->gResult : Symbol(gResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 13, 3)) ->g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 3)) +>gResult : Symbol(gResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 3)) +>g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 3)) let h = bar(x => x); ->h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) ->bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 3, 1)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 12)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 12)) +>h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 3)) +>bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 2, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 12)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 12)) let hResult = h("foo"); ->hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 16, 3)) ->h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 3)) hResult = h("bar"); ->hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 16, 3)) ->h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types index fe9163fc819..0ff65175866 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint01.ts === - function foo(f: (x: T) => T) { >foo : (f: (x: T) => T) => (x: T) => T >T : T diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js index 173e74a6eef..0a0dbb3b833 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTypeParameterConstraint02.ts] - function foo(f: (x: T) => T) { return f; } diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols index 1c5eb457788..fbf9a7fbb51 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint02.ts === - function foo(f: (x: T) => T) { >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 0)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 13)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 30)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 34)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 13)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 13)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 30)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 34)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 13)) return f; ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 30)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 30)) } let f = foo((y: "foo" | "bar") => y === "foo" ? y : "foo"); ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 3)) >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 0)) ->y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 13)) ->y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 13)) ->y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 13)) +>y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 13)) +>y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 13)) +>y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 13)) let fResult = f("foo"); ->fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 6, 3)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 3)) +>fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types index 3a1b8fdc05c..d270c4dd4bb 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint02.ts === - function foo(f: (x: T) => T) { >foo : (f: (x: T) => T) => (x: T) => T >T : T diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js index bdf06d393aa..b8e3f620690 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes01.ts] - type T = "foo" | "bar" | "baz"; var x: "foo" | "bar" | "baz" = undefined; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols index 15a8db13cd0..d4c8740d3b7 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols @@ -1,54 +1,53 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes01.ts === - type T = "foo" | "bar" | "baz"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes01.ts, 0, 0)) var x: "foo" | "bar" | "baz" = undefined; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) >undefined : Symbol(undefined) var y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes01.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "foo") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes01.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes01.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) } else if (x !== "bar") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) let b = x || y; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes01.ts, 10, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes01.ts, 9, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) } else { let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 12, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) let d = y; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 14, 7)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) let e: (typeof x) | (typeof y) = c || d; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes01.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 14, 7)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes01.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 12, 7)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) } x = y; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) y = x; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types index 96ec536f82f..60a5383cafd 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes01.ts === - type T = "foo" | "bar" | "baz"; >T : "foo" | "bar" | "baz" diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js index bca25e744c9..8c0d5bd6fe3 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes02.ts] - type T = string | "foo" | "bar" | "baz"; var x: "foo" | "bar" | "baz" | string = undefined; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols index c35b7a0691b..aadc84b9256 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols @@ -1,54 +1,53 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes02.ts === - type T = string | "foo" | "bar" | "baz"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes02.ts, 0, 0)) var x: "foo" | "bar" | "baz" | string = undefined; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) >undefined : Symbol(undefined) var y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes02.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "foo") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes02.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes02.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) } else if (x !== "bar") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) let b = x || y; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes02.ts, 10, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes02.ts, 9, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) } else { let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 12, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) let d = y; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 14, 7)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) let e: (typeof x) | (typeof y) = c || d; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes02.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 14, 7)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes02.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 12, 7)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) } x = y; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) y = x; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types index 85378108298..7d754d738a3 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes02.ts === - type T = string | "foo" | "bar" | "baz"; >T : string diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js index 6264c99c13d..c635c2df53c 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes03.ts] - type T = number | "foo" | "bar"; var x: "foo" | "bar" | number; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols index 6d519e24225..4b599d1e57b 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols @@ -1,53 +1,52 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes03.ts === - type T = number | "foo" | "bar"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes03.ts, 0, 0)) var x: "foo" | "bar" | number; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) var y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes03.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "foo") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes03.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes03.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) } else if (x !== "bar") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) let b = x || y; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes03.ts, 10, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes03.ts, 9, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) } else { let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 12, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) let d = y; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 14, 7)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) let e: (typeof x) | (typeof y) = c || d; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes03.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 14, 7)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes03.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 12, 7)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) } x = y; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) y = x; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types index 99a729c7cf9..df1edad9da3 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes03.ts === - type T = number | "foo" | "bar"; >T : number | "foo" | "bar" diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js index 85c9a30c49d..967014d58a6 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes04.ts] - type T = "" | "foo"; let x: T = undefined; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols index 9904fa8613f..16289b25d1a 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols @@ -1,78 +1,77 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes04.ts === - type T = "" | "foo"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes04.ts, 0, 0)) let x: T = undefined; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes04.ts, 0, 0)) >undefined : Symbol(undefined) let y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes04.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes04.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes04.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes04.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x !== "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let b = x; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes04.ts, 11, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes04.ts, 10, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x == "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes04.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes04.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x != "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let d = x; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes04.ts, 19, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes04.ts, 18, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let e = x; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes04.ts, 23, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes04.ts, 22, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (!x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let f = x; ->f : Symbol(f, Decl(stringLiteralTypesInUnionTypes04.ts, 27, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>f : Symbol(f, Decl(stringLiteralTypesInUnionTypes04.ts, 26, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (!!x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let g = x; ->g : Symbol(g, Decl(stringLiteralTypesInUnionTypes04.ts, 31, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>g : Symbol(g, Decl(stringLiteralTypesInUnionTypes04.ts, 30, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (!!!x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let h = x; ->h : Symbol(h, Decl(stringLiteralTypesInUnionTypes04.ts, 35, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>h : Symbol(h, Decl(stringLiteralTypesInUnionTypes04.ts, 34, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types index 05b6b9b9b7a..20f48d9e72d 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes04.ts === - type T = "" | "foo"; >T : T diff --git a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt index 2534a07132e..1e68c42b06d 100644 --- a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesInVariableDeclarations01.ts(5,7): error TS1155: 'const' declarations must be initialized. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesInVariableDeclarations01.ts(4,7): error TS1155: 'const' declarations must be initialized. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesInVariableDeclarations01.ts (1 errors) ==== - let a: ""; var b: "foo"; let c: "bar"; diff --git a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js index 15a4ca5d580..61f92b811c4 100644 --- a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js +++ b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInVariableDeclarations01.ts] - let a: ""; var b: "foo"; let c: "bar"; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt index 8010b31a9d0..6372cb491e8 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(15,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(14,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"foo"' is not assignable to type '"bar"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(16,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(15,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"bar"' is not assignable to type '"foo"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts (2 errors) ==== - function f(x: "foo"): number; function f(x: string): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js index 7b7c84165f3..47211cb6d4c 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability01.ts] - function f(x: "foo"): number; function f(x: string): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt index 8fe5a676aab..fe4b3a935dc 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(15,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(14,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"foo"' is not assignable to type '"bar"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(16,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(15,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"bar"' is not assignable to type '"foo"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts (2 errors) ==== - function f(x: "foo"): number; function f(x: "foo"): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js index 7a8db4722a6..f8d0f6fa91f 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability02.ts] - function f(x: "foo"): number; function f(x: "foo"): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js index 1d9452a9c65..4f6c11d775f 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability03.ts] - function f(x: "foo"): number; function f(x: string): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols index 361f9e9db4d..bf54266e4a7 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols @@ -1,40 +1,39 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability03.ts === - function f(x: "foo"): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 11)) function f(x: string): number { ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 2, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 11)) return 0; } function g(x: "foo"): number; ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 11)) function g(x: string): number { ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 7, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 11)) return 0; } let a = f; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 29)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 10, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 29)) let b = g; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 12, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 29)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 29)) a = b; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 12, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 10, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) b = a; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 12, 3)) ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 10, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types index 00af8e68373..b75b94626dc 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability03.ts === - function f(x: "foo"): number; >f : (x: "foo") => number >x : "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js index 975c7d80cb5..ee6d63a744e 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability04.ts] - function f(x: "foo"): number; function f(x: "foo"): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols index 75f7d12c25f..e55f7a3306a 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols @@ -1,40 +1,39 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability04.ts === - function f(x: "foo"): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 11)) function f(x: "foo"): number { ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 2, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 11)) return 0; } function g(x: "foo"): number; ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 11)) function g(x: "foo"): number { ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 7, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 11)) return 0; } let a = f; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 29)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 10, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 29)) let b = g; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 12, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 29)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 29)) a = b; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 12, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 10, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) b = a; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 12, 3)) ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 10, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types index 694a300d3d3..76f41f6337e 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability04.ts === - function f(x: "foo"): number; >f : (x: "foo") => number >x : "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js index b08dbc04082..aba8f4fe52d 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability05.ts] - function f(x: "foo"): number; function f(x: string): number; function f(x: string): number { diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols index 9a59a7c929a..ca6f42f1174 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols @@ -1,44 +1,43 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability05.ts === - function f(x: "foo"): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 11)) function f(x: string): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 11)) function f(x: string): number { ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 3, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 11)) return 0; } function g(x: "foo"): number; ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 5, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 11)) function g(x: string): number { ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 5, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 8, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 11)) return 0; } let a = f; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 11, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) let b = g; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 13, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 5, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 29)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 29)) a = b; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 13, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 11, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) b = a; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 13, 3)) ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 11, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types index 925d2547411..925cda1997b 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability05.ts === - function f(x: "foo"): number; >f : { (x: "foo"): number; (x: string): number; } >x : "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.js b/tests/baselines/reference/stringLiteralTypesOverloads01.js index dd050b5e464..06b8b467543 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads01.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads01.ts] - type PrimitiveName = 'string' | 'number' | 'boolean'; function getFalsyPrimitive(x: "string"): string; diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.symbols b/tests/baselines/reference/stringLiteralTypesOverloads01.symbols index c92fe134076..6409904e7d1 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads01.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads01.symbols @@ -1,53 +1,52 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts === - type PrimitiveName = 'string' | 'number' | 'boolean'; >PrimitiveName : Symbol(PrimitiveName, Decl(stringLiteralTypesOverloads01.ts, 0, 0)) function getFalsyPrimitive(x: "string"): string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 3, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 2, 27)) function getFalsyPrimitive(x: "number"): number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 4, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 3, 27)) function getFalsyPrimitive(x: "boolean"): boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 5, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 4, 27)) function getFalsyPrimitive(x: "boolean" | "string"): boolean | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 6, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 5, 27)) function getFalsyPrimitive(x: "boolean" | "number"): boolean | number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 7, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 6, 27)) function getFalsyPrimitive(x: "number" | "string"): number | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 8, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 7, 27)) function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 8, 27)) function getFalsyPrimitive(x: PrimitiveName): number | string | boolean { ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) >PrimitiveName : Symbol(PrimitiveName, Decl(stringLiteralTypesOverloads01.ts, 0, 0)) if (x === "string") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) return ""; } if (x === "number") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) return 0; } if (x === "boolean") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) return false; } @@ -57,87 +56,87 @@ function getFalsyPrimitive(x: PrimitiveName): number | string | boolean { } namespace Consts1 { ->Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads01.ts, 23, 1)) +>Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads01.ts, 22, 1)) const EMPTY_STRING = getFalsyPrimitive("string"); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 26, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 25, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) const ZERO = getFalsyPrimitive('number'); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 27, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 26, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) const FALSE = getFalsyPrimitive("boolean"); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 28, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 27, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) } const string: "string" = "string" ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) const number: "number" = "number" ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) const boolean: "boolean" = "boolean" ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const stringOrNumber = string || number; ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 34, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) const stringOrBoolean = string || boolean; ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const booleanOrNumber = number || boolean; ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const stringOrBooleanOrNumber = stringOrBoolean || number; ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 38, 5)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) namespace Consts2 { ->Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads01.ts, 38, 58)) +>Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads01.ts, 37, 58)) const EMPTY_STRING = getFalsyPrimitive(string); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 41, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 40, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) const ZERO = getFalsyPrimitive(number); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 42, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 41, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) const FALSE = getFalsyPrimitive(boolean); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 43, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 42, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const a = getFalsyPrimitive(stringOrNumber); ->a : Symbol(a, Decl(stringLiteralTypesOverloads01.ts, 45, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) +>a : Symbol(a, Decl(stringLiteralTypesOverloads01.ts, 44, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 34, 5)) const b = getFalsyPrimitive(stringOrBoolean); ->b : Symbol(b, Decl(stringLiteralTypesOverloads01.ts, 46, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) +>b : Symbol(b, Decl(stringLiteralTypesOverloads01.ts, 45, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) const c = getFalsyPrimitive(booleanOrNumber); ->c : Symbol(c, Decl(stringLiteralTypesOverloads01.ts, 47, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) +>c : Symbol(c, Decl(stringLiteralTypesOverloads01.ts, 46, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) const d = getFalsyPrimitive(stringOrBooleanOrNumber); ->d : Symbol(d, Decl(stringLiteralTypesOverloads01.ts, 48, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 38, 5)) +>d : Symbol(d, Decl(stringLiteralTypesOverloads01.ts, 47, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) } diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.types b/tests/baselines/reference/stringLiteralTypesOverloads01.types index 2a0bc61f3e8..bceb5112947 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads01.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts === - type PrimitiveName = 'string' | 'number' | 'boolean'; >PrimitiveName : PrimitiveName diff --git a/tests/baselines/reference/stringLiteralTypesOverloads02.js b/tests/baselines/reference/stringLiteralTypesOverloads02.js index c0a7622075a..97b635f7dc0 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads02.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads02.ts] - function getFalsyPrimitive(x: "string"): string; function getFalsyPrimitive(x: "number"): number; function getFalsyPrimitive(x: "boolean"): boolean; diff --git a/tests/baselines/reference/stringLiteralTypesOverloads02.symbols b/tests/baselines/reference/stringLiteralTypesOverloads02.symbols index 1bbedacf8a5..1dee747d64b 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads02.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads02.symbols @@ -1,49 +1,48 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads02.ts === - function getFalsyPrimitive(x: "string"): string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 1, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 0, 27)) function getFalsyPrimitive(x: "number"): number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 2, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 1, 27)) function getFalsyPrimitive(x: "boolean"): boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 3, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 2, 27)) function getFalsyPrimitive(x: "boolean" | "string"): boolean | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 4, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 3, 27)) function getFalsyPrimitive(x: "boolean" | "number"): boolean | number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 5, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 4, 27)) function getFalsyPrimitive(x: "number" | "string"): number | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 6, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 5, 27)) function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 6, 27)) function getFalsyPrimitive(x: string): string | number | boolean { ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) if (x === "string") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) return ""; } if (x === "number") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) return 0; } if (x === "boolean") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) return false; } @@ -53,87 +52,87 @@ function getFalsyPrimitive(x: string): string | number | boolean { } namespace Consts1 { ->Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads02.ts, 21, 1)) +>Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads02.ts, 20, 1)) const EMPTY_STRING = getFalsyPrimitive("string"); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 24, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 23, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) const ZERO = getFalsyPrimitive('number'); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 25, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 24, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) const FALSE = getFalsyPrimitive("boolean"); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 26, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 25, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) } const string = "string" ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) const number = "number" ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) const boolean = "boolean" ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const stringOrNumber = string || number; ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 32, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) const stringOrBoolean = string || boolean; ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const booleanOrNumber = number || boolean; ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const stringOrBooleanOrNumber = stringOrBoolean || number; ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 36, 5)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) namespace Consts2 { ->Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads02.ts, 36, 58)) +>Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads02.ts, 35, 58)) const EMPTY_STRING = getFalsyPrimitive(string); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 39, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 38, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) const ZERO = getFalsyPrimitive(number); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 40, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 39, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) const FALSE = getFalsyPrimitive(boolean); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 41, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 40, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const a = getFalsyPrimitive(stringOrNumber); ->a : Symbol(a, Decl(stringLiteralTypesOverloads02.ts, 43, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) +>a : Symbol(a, Decl(stringLiteralTypesOverloads02.ts, 42, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 32, 5)) const b = getFalsyPrimitive(stringOrBoolean); ->b : Symbol(b, Decl(stringLiteralTypesOverloads02.ts, 44, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) +>b : Symbol(b, Decl(stringLiteralTypesOverloads02.ts, 43, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) const c = getFalsyPrimitive(booleanOrNumber); ->c : Symbol(c, Decl(stringLiteralTypesOverloads02.ts, 45, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) +>c : Symbol(c, Decl(stringLiteralTypesOverloads02.ts, 44, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) const d = getFalsyPrimitive(stringOrBooleanOrNumber); ->d : Symbol(d, Decl(stringLiteralTypesOverloads02.ts, 46, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 36, 5)) +>d : Symbol(d, Decl(stringLiteralTypesOverloads02.ts, 45, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) } diff --git a/tests/baselines/reference/stringLiteralTypesOverloads02.types b/tests/baselines/reference/stringLiteralTypesOverloads02.types index 7122929e85d..93c3316bc3a 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads02.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads02.ts === - function getFalsyPrimitive(x: "string"): string; >getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "string" | "boolean"): string | boolean; (x: "number" | "boolean"): number | boolean; (x: "string" | "number"): string | number; (x: "string" | "number" | "boolean"): string | number | boolean; } >x : "string" diff --git a/tests/baselines/reference/stringLiteralTypesOverloads03.js b/tests/baselines/reference/stringLiteralTypesOverloads03.js index 4fdfd4f85d0..6aec13ee21e 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads03.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads03.ts] - interface Base { x: string; y: number; diff --git a/tests/baselines/reference/stringLiteralTypesOverloads03.symbols b/tests/baselines/reference/stringLiteralTypesOverloads03.symbols index 277cc7e84e3..afcff865a45 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads03.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads03.symbols @@ -1,131 +1,130 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads03.ts === - interface Base { >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) x: string; ->x : Symbol(Base.x, Decl(stringLiteralTypesOverloads03.ts, 1, 16)) +>x : Symbol(Base.x, Decl(stringLiteralTypesOverloads03.ts, 0, 16)) y: number; ->y : Symbol(Base.y, Decl(stringLiteralTypesOverloads03.ts, 2, 14)) +>y : Symbol(Base.y, Decl(stringLiteralTypesOverloads03.ts, 1, 14)) } interface HelloOrWorld extends Base { ->HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 4, 1)) +>HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 3, 1)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) p1: boolean; ->p1 : Symbol(HelloOrWorld.p1, Decl(stringLiteralTypesOverloads03.ts, 6, 37)) +>p1 : Symbol(HelloOrWorld.p1, Decl(stringLiteralTypesOverloads03.ts, 5, 37)) } interface JustHello extends Base { ->JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 8, 1)) +>JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 7, 1)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) p2: boolean; ->p2 : Symbol(JustHello.p2, Decl(stringLiteralTypesOverloads03.ts, 10, 34)) +>p2 : Symbol(JustHello.p2, Decl(stringLiteralTypesOverloads03.ts, 9, 34)) } interface JustWorld extends Base { ->JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 12, 1)) +>JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 11, 1)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) p3: boolean; ->p3 : Symbol(JustWorld.p3, Decl(stringLiteralTypesOverloads03.ts, 14, 34)) +>p3 : Symbol(JustWorld.p3, Decl(stringLiteralTypesOverloads03.ts, 13, 34)) } let hello: "hello"; ->hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) +>hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 17, 3)) let world: "world"; ->world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) +>world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) let helloOrWorld: "hello" | "world"; ->helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 20, 3)) +>helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) function f(p: "hello"): JustHello; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 22, 11)) ->JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 8, 1)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 21, 11)) +>JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 7, 1)) function f(p: "hello" | "world"): HelloOrWorld; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 23, 11)) ->HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 4, 1)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 22, 11)) +>HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 3, 1)) function f(p: "world"): JustWorld; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 24, 11)) ->JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 12, 1)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 23, 11)) +>JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 11, 1)) function f(p: string): Base; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 25, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 24, 11)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) function f(...args: any[]): any { ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 26, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 25, 11)) return undefined; >undefined : Symbol(undefined) } let fResult1 = f(hello); ->fResult1 : Symbol(fResult1, Decl(stringLiteralTypesOverloads03.ts, 30, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) +>fResult1 : Symbol(fResult1, Decl(stringLiteralTypesOverloads03.ts, 29, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 17, 3)) let fResult2 = f(world); ->fResult2 : Symbol(fResult2, Decl(stringLiteralTypesOverloads03.ts, 31, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) +>fResult2 : Symbol(fResult2, Decl(stringLiteralTypesOverloads03.ts, 30, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) let fResult3 = f(helloOrWorld); ->fResult3 : Symbol(fResult3, Decl(stringLiteralTypesOverloads03.ts, 32, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 20, 3)) +>fResult3 : Symbol(fResult3, Decl(stringLiteralTypesOverloads03.ts, 31, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) function g(p: string): Base; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 34, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 33, 11)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) function g(p: "hello"): JustHello; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 35, 11)) ->JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 8, 1)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 34, 11)) +>JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 7, 1)) function g(p: "hello" | "world"): HelloOrWorld; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 36, 11)) ->HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 4, 1)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 35, 11)) +>HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 3, 1)) function g(p: "world"): JustWorld; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 37, 11)) ->JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 12, 1)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 36, 11)) +>JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 11, 1)) function g(...args: any[]): any { ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 38, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 37, 11)) return undefined; >undefined : Symbol(undefined) } let gResult1 = g(hello); ->gResult1 : Symbol(gResult1, Decl(stringLiteralTypesOverloads03.ts, 42, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) +>gResult1 : Symbol(gResult1, Decl(stringLiteralTypesOverloads03.ts, 41, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 17, 3)) let gResult2 = g(world); ->gResult2 : Symbol(gResult2, Decl(stringLiteralTypesOverloads03.ts, 43, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) +>gResult2 : Symbol(gResult2, Decl(stringLiteralTypesOverloads03.ts, 42, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) let gResult3 = g(helloOrWorld); ->gResult3 : Symbol(gResult3, Decl(stringLiteralTypesOverloads03.ts, 44, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 20, 3)) +>gResult3 : Symbol(gResult3, Decl(stringLiteralTypesOverloads03.ts, 43, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloads03.types b/tests/baselines/reference/stringLiteralTypesOverloads03.types index 643979ee987..8fcf1745f2a 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads03.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads03.ts === - interface Base { >Base : Base diff --git a/tests/baselines/reference/stringLiteralTypesOverloads04.js b/tests/baselines/reference/stringLiteralTypesOverloads04.js index 81e123c3e57..4d16d072fa5 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads04.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads04.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads04.ts] - declare function f(x: (p: "foo" | "bar") => "foo"); f(y => { diff --git a/tests/baselines/reference/stringLiteralTypesOverloads04.symbols b/tests/baselines/reference/stringLiteralTypesOverloads04.symbols index de1951d325a..57398948aa8 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads04.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads04.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads04.ts === - declare function f(x: (p: "foo" | "bar") => "foo"); >f : Symbol(f, Decl(stringLiteralTypesOverloads04.ts, 0, 0)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads04.ts, 1, 19)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads04.ts, 1, 23)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads04.ts, 0, 19)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads04.ts, 0, 23)) f(y => { >f : Symbol(f, Decl(stringLiteralTypesOverloads04.ts, 0, 0)) ->y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 3, 2)) +>y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 2, 2)) const z = y = "foo"; ->z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 4, 9)) ->y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 3, 2)) +>z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 3, 9)) +>y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 2, 2)) return z; ->z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 4, 9)) +>z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 3, 9)) }) diff --git a/tests/baselines/reference/stringLiteralTypesOverloads04.types b/tests/baselines/reference/stringLiteralTypesOverloads04.types index 8cb8b2a7cea..a68d9ddf9a5 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads04.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads04.ts === - declare function f(x: (p: "foo" | "bar") => "foo"); >f : (x: (p: "foo" | "bar") => "foo") => any >x : (p: "foo" | "bar") => "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt b/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt index e57327ab0e0..027feb7cc31 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads05.ts(7,10): error TS2394: Overload signature is not compatible with function implementation. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads05.ts(6,10): error TS2394: Overload signature is not compatible with function implementation. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads05.ts (1 errors) ==== - interface Animal { animal: {} }; interface Dog extends Animal { dog: {} } interface Cat extends Animal { cat: {} } diff --git a/tests/baselines/reference/stringLiteralTypesOverloads05.js b/tests/baselines/reference/stringLiteralTypesOverloads05.js index 23be3dac1e1..7848a57819a 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads05.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads05.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads05.ts] - interface Animal { animal: {} }; interface Dog extends Animal { dog: {} } interface Cat extends Animal { cat: {} } diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.js b/tests/baselines/reference/stringLiteralTypesTypePredicates01.js index fdd03c83aa5..cf22198f48d 100644 --- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.js +++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesTypePredicates01.ts] - type Kind = "A" | "B" function kindIs(kind: Kind, is: "A"): kind is "A"; diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols b/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols index aea8c6ac262..42b1e78703a 100644 --- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols +++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols @@ -1,63 +1,62 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesTypePredicates01.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) function kindIs(kind: Kind, is: "A"): kind is "A"; ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) +>kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 2, 16)) +>Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) +>is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 2, 27)) +>kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 2, 16)) + +function kindIs(kind: Kind, is: "B"): kind is "B"; +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) >kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 3, 16)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) >is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 3, 27)) >kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 3, 16)) -function kindIs(kind: Kind, is: "B"): kind is "B"; ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) +function kindIs(kind: Kind, is: Kind): boolean { +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) >kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 4, 16)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) >is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 4, 27)) ->kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 4, 16)) - -function kindIs(kind: Kind, is: Kind): boolean { ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) ->kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 5, 16)) ->Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) ->is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 5, 27)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) return kind === is; ->kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 5, 16)) ->is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 5, 27)) +>kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 4, 16)) +>is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 4, 27)) } var x: Kind = undefined; ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) >undefined : Symbol(undefined) if (kindIs(x, "A")) { ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesTypePredicates01.ts, 12, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>a : Symbol(a, Decl(stringLiteralTypesTypePredicates01.ts, 11, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesTypePredicates01.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>b : Symbol(b, Decl(stringLiteralTypesTypePredicates01.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } if (!kindIs(x, "B")) { ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesTypePredicates01.ts, 19, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>c : Symbol(c, Decl(stringLiteralTypesTypePredicates01.ts, 18, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesTypePredicates01.ts, 22, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>d : Symbol(d, Decl(stringLiteralTypesTypePredicates01.ts, 21, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.types b/tests/baselines/reference/stringLiteralTypesTypePredicates01.types index 822103b86f5..ab5c40ae620 100644 --- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.types +++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesTypePredicates01.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt index 3851a0b10ef..a1819ddb82f 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(2,5): error TS2322: Type 'string' is not assignable to type '"ABC"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(3,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(6,5): error TS2322: Type 'string' is not assignable to type '"JK`L"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(1,5): error TS2322: Type 'string' is not assignable to type '"ABC"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(2,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(5,5): error TS2322: Type 'string' is not assignable to type '"JK`L"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts (3 errors) ==== - let ABC: "ABC" = `ABC`; ~~~ !!! error TS2322: Type 'string' is not assignable to type '"ABC"'. diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js index 8f548afc7bf..f1833b55c20 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithTemplateStrings01.ts] - let ABC: "ABC" = `ABC`; let DE_NEWLINE_F: "DE\nF" = `DE F`; diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt index 803e4f5cb24..8c69e595e25 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(2,5): error TS2322: Type 'string' is not assignable to type '"AB\r\nC"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(4,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(1,5): error TS2322: Type 'string' is not assignable to type '"AB\r\nC"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(3,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts (2 errors) ==== - let abc: "AB\r\nC" = `AB ~~~ !!! error TS2322: Type 'string' is not assignable to type '"AB\r\nC"'. diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js index f5d9045921a..8d675eeb9c4 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithTemplateStrings02.ts] - let abc: "AB\r\nC" = `AB C`; let de_NEWLINE_f: "DE\nF" = `DE${"\n"}F`; diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js index 1576540e244..08c3f4aa4b7 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithVariousOperators01.ts] - let abc: "ABC" = "ABC"; let xyz: "XYZ" = "XYZ"; let abcOrXyz: "ABC" | "XYZ" = abc || xyz; diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols index cc9c3aa842b..b226c964143 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols @@ -1,116 +1,115 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators01.ts === - let abc: "ABC" = "ABC"; ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let xyz: "XYZ" = "XYZ"; ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let abcOrXyz: "ABC" | "XYZ" = abc || xyz; ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let abcOrXyzOrNumber: "ABC" | "XYZ" | number = abcOrXyz || 100; ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let a = "" + abc; ->a : Symbol(a, Decl(stringLiteralTypesWithVariousOperators01.ts, 6, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>a : Symbol(a, Decl(stringLiteralTypesWithVariousOperators01.ts, 5, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let b = abc + ""; ->b : Symbol(b, Decl(stringLiteralTypesWithVariousOperators01.ts, 7, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>b : Symbol(b, Decl(stringLiteralTypesWithVariousOperators01.ts, 6, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let c = 10 + abc; ->c : Symbol(c, Decl(stringLiteralTypesWithVariousOperators01.ts, 8, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>c : Symbol(c, Decl(stringLiteralTypesWithVariousOperators01.ts, 7, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let d = abc + 10; ->d : Symbol(d, Decl(stringLiteralTypesWithVariousOperators01.ts, 9, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>d : Symbol(d, Decl(stringLiteralTypesWithVariousOperators01.ts, 8, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let e = xyz + abc; ->e : Symbol(e, Decl(stringLiteralTypesWithVariousOperators01.ts, 10, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>e : Symbol(e, Decl(stringLiteralTypesWithVariousOperators01.ts, 9, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let f = abc + xyz; ->f : Symbol(f, Decl(stringLiteralTypesWithVariousOperators01.ts, 11, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>f : Symbol(f, Decl(stringLiteralTypesWithVariousOperators01.ts, 10, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let g = true + abc; ->g : Symbol(g, Decl(stringLiteralTypesWithVariousOperators01.ts, 12, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>g : Symbol(g, Decl(stringLiteralTypesWithVariousOperators01.ts, 11, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let h = abc + true; ->h : Symbol(h, Decl(stringLiteralTypesWithVariousOperators01.ts, 13, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>h : Symbol(h, Decl(stringLiteralTypesWithVariousOperators01.ts, 12, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let i = abc + abcOrXyz + xyz; ->i : Symbol(i, Decl(stringLiteralTypesWithVariousOperators01.ts, 14, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>i : Symbol(i, Decl(stringLiteralTypesWithVariousOperators01.ts, 13, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let j = abcOrXyz + abcOrXyz; ->j : Symbol(j, Decl(stringLiteralTypesWithVariousOperators01.ts, 15, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>j : Symbol(j, Decl(stringLiteralTypesWithVariousOperators01.ts, 14, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let k = +abcOrXyz; ->k : Symbol(k, Decl(stringLiteralTypesWithVariousOperators01.ts, 16, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>k : Symbol(k, Decl(stringLiteralTypesWithVariousOperators01.ts, 15, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let l = -abcOrXyz; ->l : Symbol(l, Decl(stringLiteralTypesWithVariousOperators01.ts, 17, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>l : Symbol(l, Decl(stringLiteralTypesWithVariousOperators01.ts, 16, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let m = abcOrXyzOrNumber + ""; ->m : Symbol(m, Decl(stringLiteralTypesWithVariousOperators01.ts, 18, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>m : Symbol(m, Decl(stringLiteralTypesWithVariousOperators01.ts, 17, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let n = "" + abcOrXyzOrNumber; ->n : Symbol(n, Decl(stringLiteralTypesWithVariousOperators01.ts, 19, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>n : Symbol(n, Decl(stringLiteralTypesWithVariousOperators01.ts, 18, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let o = abcOrXyzOrNumber + abcOrXyz; ->o : Symbol(o, Decl(stringLiteralTypesWithVariousOperators01.ts, 20, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>o : Symbol(o, Decl(stringLiteralTypesWithVariousOperators01.ts, 19, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let p = abcOrXyz + abcOrXyzOrNumber; ->p : Symbol(p, Decl(stringLiteralTypesWithVariousOperators01.ts, 21, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>p : Symbol(p, Decl(stringLiteralTypesWithVariousOperators01.ts, 20, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let q = !abcOrXyzOrNumber; ->q : Symbol(q, Decl(stringLiteralTypesWithVariousOperators01.ts, 22, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>q : Symbol(q, Decl(stringLiteralTypesWithVariousOperators01.ts, 21, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let r = ~abcOrXyzOrNumber; ->r : Symbol(r, Decl(stringLiteralTypesWithVariousOperators01.ts, 23, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>r : Symbol(r, Decl(stringLiteralTypesWithVariousOperators01.ts, 22, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let s = abcOrXyzOrNumber < abcOrXyzOrNumber; ->s : Symbol(s, Decl(stringLiteralTypesWithVariousOperators01.ts, 24, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypesWithVariousOperators01.ts, 23, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let t = abcOrXyzOrNumber >= abcOrXyz; ->t : Symbol(t, Decl(stringLiteralTypesWithVariousOperators01.ts, 25, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>t : Symbol(t, Decl(stringLiteralTypesWithVariousOperators01.ts, 24, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let u = abc === abcOrXyz; ->u : Symbol(u, Decl(stringLiteralTypesWithVariousOperators01.ts, 26, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>u : Symbol(u, Decl(stringLiteralTypesWithVariousOperators01.ts, 25, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let v = abcOrXyz === abcOrXyzOrNumber; ->v : Symbol(v, Decl(stringLiteralTypesWithVariousOperators01.ts, 27, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>v : Symbol(v, Decl(stringLiteralTypesWithVariousOperators01.ts, 26, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types index 46dfef010a0..4241ca267f6 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators01.ts === - let abc: "ABC" = "ABC"; >abc : "ABC" >"ABC" : "ABC" diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt index a4944f7f163..03fa065fcd3 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt @@ -1,18 +1,17 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(7,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and '100'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(8,9): error TS2365: Operator '+' cannot be applied to types '100' and 'number | "ABC" | "XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(9,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'number | "ABC" | "XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(10,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'true'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(11,9): error TS2365: Operator '+' cannot be applied to types 'false' and 'number | "ABC" | "XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(12,9): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(13,11): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(6,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and '100'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(7,9): error TS2365: Operator '+' cannot be applied to types '100' and 'number | "ABC" | "XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(8,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'number | "ABC" | "XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(9,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'true'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(10,9): error TS2365: Operator '+' cannot be applied to types 'false' and 'number | "ABC" | "XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(11,9): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(12,11): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(13,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(14,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(17,9): error TS2365: Operator '===' cannot be applied to types '"ABC"' and '"XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(18,9): error TS2365: Operator '!=' cannot be applied to types '"ABC"' and '"XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(16,9): error TS2365: Operator '===' cannot be applied to types '"ABC"' and '"XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(17,9): error TS2365: Operator '!=' cannot be applied to types '"ABC"' and '"XYZ"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts (11 errors) ==== - let abc: "ABC" = "ABC"; let xyz: "XYZ" = "XYZ"; let abcOrXyz: "ABC" | "XYZ" = abc || xyz; diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js index 4914ecf3d17..fe64c263af6 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithVariousOperators02.ts] - let abc: "ABC" = "ABC"; let xyz: "XYZ" = "XYZ"; let abcOrXyz: "ABC" | "XYZ" = abc || xyz; diff --git a/tests/baselines/reference/stripInternal1.js b/tests/baselines/reference/stripInternal1.js index e5fbe40df7a..475904906f0 100644 --- a/tests/baselines/reference/stripInternal1.js +++ b/tests/baselines/reference/stripInternal1.js @@ -1,5 +1,4 @@ //// [stripInternal1.ts] - class C { foo(): void { } // @internal diff --git a/tests/baselines/reference/stripInternal1.symbols b/tests/baselines/reference/stripInternal1.symbols index dd53f671bc9..d49d8387808 100644 --- a/tests/baselines/reference/stripInternal1.symbols +++ b/tests/baselines/reference/stripInternal1.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/stripInternal1.ts === - class C { >C : Symbol(C, Decl(stripInternal1.ts, 0, 0)) foo(): void { } ->foo : Symbol(C.foo, Decl(stripInternal1.ts, 1, 9)) +>foo : Symbol(C.foo, Decl(stripInternal1.ts, 0, 9)) // @internal bar(): void { } ->bar : Symbol(C.bar, Decl(stripInternal1.ts, 2, 17)) +>bar : Symbol(C.bar, Decl(stripInternal1.ts, 1, 17)) } diff --git a/tests/baselines/reference/stripInternal1.types b/tests/baselines/reference/stripInternal1.types index 8452de45596..49c2d420477 100644 --- a/tests/baselines/reference/stripInternal1.types +++ b/tests/baselines/reference/stripInternal1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/stripInternal1.ts === - class C { >C : C diff --git a/tests/baselines/reference/structuralTypeInDeclareFileForModule.js b/tests/baselines/reference/structuralTypeInDeclareFileForModule.js index b7d5615d3ff..c7577432b76 100644 --- a/tests/baselines/reference/structuralTypeInDeclareFileForModule.js +++ b/tests/baselines/reference/structuralTypeInDeclareFileForModule.js @@ -1,5 +1,4 @@ //// [structuralTypeInDeclareFileForModule.ts] - module M { export var x; } var m = M; diff --git a/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols b/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols index 93aa04ba6bb..c28a454e266 100644 --- a/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols +++ b/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/structuralTypeInDeclareFileForModule.ts === - module M { export var x; } >M : Symbol(M, Decl(structuralTypeInDeclareFileForModule.ts, 0, 0)) ->x : Symbol(x, Decl(structuralTypeInDeclareFileForModule.ts, 1, 21)) +>x : Symbol(x, Decl(structuralTypeInDeclareFileForModule.ts, 0, 21)) var m = M; ->m : Symbol(m, Decl(structuralTypeInDeclareFileForModule.ts, 2, 3)) +>m : Symbol(m, Decl(structuralTypeInDeclareFileForModule.ts, 1, 3)) >M : Symbol(M, Decl(structuralTypeInDeclareFileForModule.ts, 0, 0)) diff --git a/tests/baselines/reference/structuralTypeInDeclareFileForModule.types b/tests/baselines/reference/structuralTypeInDeclareFileForModule.types index ff023a79133..4fd3b51643b 100644 --- a/tests/baselines/reference/structuralTypeInDeclareFileForModule.types +++ b/tests/baselines/reference/structuralTypeInDeclareFileForModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/structuralTypeInDeclareFileForModule.ts === - module M { export var x; } >M : typeof M >x : any diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt index f491cac9f0c..f4d6a4c4e5d 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(8,17): error TS2314: Generic type 'A' requires 2 type argument(s). +tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(7,17): error TS2314: Generic type 'A' requires 2 type argument(s). ==== tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts (1 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js index 18038207125..a80ea5c047d 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt index 32047f3b417..3bf76b099e8 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(8,17): error TS2314: Generic type 'A' requires 2 type argument(s). +tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(7,17): error TS2314: Generic type 'A' requires 2 type argument(s). ==== tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts (1 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js index 77b0f4af212..c73e6d6cb44 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt index 4aa9e5a134b..6b3390493c4 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(8,17): error TS2315: Type 'A' is not generic. +tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(7,17): error TS2315: Type 'A' is not generic. ==== tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts (1 errors) ==== - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js index 861bd9b470c..8c345104e28 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js +++ b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts] - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt index bac5abad004..99889e3ed03 100644 --- a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts(9,21): error TS2335: 'super' can only be referenced in a derived class. +tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts(8,21): error TS2335: 'super' can only be referenced in a derived class. ==== tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts (1 errors) ==== - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js index e4b358c9a0a..33cbede2ab2 100644 --- a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js +++ b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatHasNoBaseType1.ts] - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromFunction1.errors.txt b/tests/baselines/reference/superCallFromFunction1.errors.txt index b993d9f1253..4c5c58c1d8c 100644 --- a/tests/baselines/reference/superCallFromFunction1.errors.txt +++ b/tests/baselines/reference/superCallFromFunction1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromFunction1.ts(3,5): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/compiler/superCallFromFunction1.ts(2,5): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/compiler/superCallFromFunction1.ts (1 errors) ==== - function foo() { super(value => String(value)); ~~~~~ diff --git a/tests/baselines/reference/superCallFromFunction1.js b/tests/baselines/reference/superCallFromFunction1.js index 7f34628c58a..308c0de6524 100644 --- a/tests/baselines/reference/superCallFromFunction1.js +++ b/tests/baselines/reference/superCallFromFunction1.js @@ -1,5 +1,4 @@ //// [superCallFromFunction1.ts] - function foo() { super(value => String(value)); } diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.js b/tests/baselines/reference/superCallParameterContextualTyping1.js index cfb0efa9d3d..c846a029c91 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.js +++ b/tests/baselines/reference/superCallParameterContextualTyping1.js @@ -1,5 +1,4 @@ //// [superCallParameterContextualTyping1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.symbols b/tests/baselines/reference/superCallParameterContextualTyping1.symbols index 91eff4b3c8b..628234537e2 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.symbols +++ b/tests/baselines/reference/superCallParameterContextualTyping1.symbols @@ -1,30 +1,29 @@ === tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping1.ts === - class A { >A : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) ->T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 1, 8)) ->T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 1, 11)) +>T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 0, 8)) +>T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 0, 11)) constructor(private map: (value: T1) => T2) { ->map : Symbol(A.map, Decl(superCallParameterContextualTyping1.ts, 2, 16)) ->value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 2, 30)) ->T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 1, 8)) ->T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 1, 11)) +>map : Symbol(A.map, Decl(superCallParameterContextualTyping1.ts, 1, 16)) +>value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 1, 30)) +>T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 0, 8)) +>T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 0, 11)) } } class B extends A { ->B : Symbol(B, Decl(superCallParameterContextualTyping1.ts, 5, 1)) +>B : Symbol(B, Decl(superCallParameterContextualTyping1.ts, 4, 1)) >A : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) // Ensure 'value' is of type 'number (and not '{}') by using its 'toExponential()' method. constructor() { super(value => String(value.toExponential())); } >super : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) ->value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26)) +>value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 8, 26)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26)) +>value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 8, 26)) >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.types b/tests/baselines/reference/superCallParameterContextualTyping1.types index 4dc68fee3f7..edba3ee3d3a 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.types +++ b/tests/baselines/reference/superCallParameterContextualTyping1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping1.ts === - class A { >A : A >T1 : T1 diff --git a/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt b/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt index 92451ffd056..040f6c6435c 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt +++ b/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping2.ts(10,43): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type 'Number' has no compatible call signatures. +tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping2.ts(9,43): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type 'Number' has no compatible call signatures. ==== tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping2.ts (1 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallParameterContextualTyping2.js b/tests/baselines/reference/superCallParameterContextualTyping2.js index f1180347142..7cd480d1b65 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping2.js +++ b/tests/baselines/reference/superCallParameterContextualTyping2.js @@ -1,5 +1,4 @@ //// [superCallParameterContextualTyping2.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superNewCall1.errors.txt b/tests/baselines/reference/superNewCall1.errors.txt index c8fd5c471fb..3ec370518c4 100644 --- a/tests/baselines/reference/superNewCall1.errors.txt +++ b/tests/baselines/reference/superNewCall1.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/superNewCall1.ts(9,5): error TS2377: Constructors for derived classes must contain a 'super' call. -tests/cases/compiler/superNewCall1.ts(10,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature. -tests/cases/compiler/superNewCall1.ts(10,13): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. +tests/cases/compiler/superNewCall1.ts(8,5): error TS2377: Constructors for derived classes must contain a 'super' call. +tests/cases/compiler/superNewCall1.ts(9,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature. +tests/cases/compiler/superNewCall1.ts(9,13): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. ==== tests/cases/compiler/superNewCall1.ts (3 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superNewCall1.js b/tests/baselines/reference/superNewCall1.js index a7a94deb6dc..687f0847fa9 100644 --- a/tests/baselines/reference/superNewCall1.js +++ b/tests/baselines/reference/superNewCall1.js @@ -1,5 +1,4 @@ //// [superNewCall1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superPropertyAccess.errors.txt b/tests/baselines/reference/superPropertyAccess.errors.txt index 22b1a1c5346..e1b81345390 100644 --- a/tests/baselines/reference/superPropertyAccess.errors.txt +++ b/tests/baselines/reference/superPropertyAccess.errors.txt @@ -1,15 +1,14 @@ +tests/cases/compiler/superPropertyAccess.ts(7,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/compiler/superPropertyAccess.ts(8,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess.ts(22,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(24,15): error TS2341: Property 'p1' is private and only accessible within class 'MyBase'. -tests/cases/compiler/superPropertyAccess.ts(26,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(28,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(32,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(34,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(21,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(23,15): error TS2341: Property 'p1' is private and only accessible within class 'MyBase'. +tests/cases/compiler/superPropertyAccess.ts(25,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(27,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(31,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(33,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superPropertyAccess.ts (8 errors) ==== - class MyBase { m1(a: string) { return a; } private p1() { } diff --git a/tests/baselines/reference/superPropertyAccess.js b/tests/baselines/reference/superPropertyAccess.js index 342e39b9885..d84bb5c08b8 100644 --- a/tests/baselines/reference/superPropertyAccess.js +++ b/tests/baselines/reference/superPropertyAccess.js @@ -1,5 +1,4 @@ //// [superPropertyAccess.ts] - class MyBase { m1(a: string) { return a; } private p1() { } diff --git a/tests/baselines/reference/superPropertyAccess_ES5.errors.txt b/tests/baselines/reference/superPropertyAccess_ES5.errors.txt index 08adcd36e68..071cfd23727 100644 --- a/tests/baselines/reference/superPropertyAccess_ES5.errors.txt +++ b/tests/baselines/reference/superPropertyAccess_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/superPropertyAccess_ES5.ts(12,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess_ES5.ts(27,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess_ES5.ts(11,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess_ES5.ts(26,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superPropertyAccess_ES5.ts (2 errors) ==== - class MyBase { getValue(): number { return 1; } get value(): number { return 1; } diff --git a/tests/baselines/reference/superPropertyAccess_ES5.js b/tests/baselines/reference/superPropertyAccess_ES5.js index 1b74519464a..406fa087a44 100644 --- a/tests/baselines/reference/superPropertyAccess_ES5.js +++ b/tests/baselines/reference/superPropertyAccess_ES5.js @@ -1,5 +1,4 @@ //// [superPropertyAccess_ES5.ts] - class MyBase { getValue(): number { return 1; } get value(): number { return 1; } diff --git a/tests/baselines/reference/superPropertyAccess_ES6.js b/tests/baselines/reference/superPropertyAccess_ES6.js index 1b23c6ca0d8..58022fd9e3d 100644 --- a/tests/baselines/reference/superPropertyAccess_ES6.js +++ b/tests/baselines/reference/superPropertyAccess_ES6.js @@ -1,5 +1,4 @@ //// [superPropertyAccess_ES6.ts] - class MyBase { getValue(): number { return 1; } get value(): number { return 1; } diff --git a/tests/baselines/reference/superPropertyAccess_ES6.symbols b/tests/baselines/reference/superPropertyAccess_ES6.symbols index 61b8ab3dc76..da2216f591c 100644 --- a/tests/baselines/reference/superPropertyAccess_ES6.symbols +++ b/tests/baselines/reference/superPropertyAccess_ES6.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/superPropertyAccess_ES6.ts === - class MyBase { >MyBase : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) getValue(): number { return 1; } ->getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 1, 14)) +>getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 0, 14)) get value(): number { return 1; } ->value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) } class MyDerived extends MyBase { ->MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 4, 1)) +>MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 3, 1)) >MyBase : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) constructor() { @@ -19,62 +18,62 @@ class MyDerived extends MyBase { >super : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) const f1 = super.getValue(); ->f1 : Symbol(f1, Decl(superPropertyAccess_ES6.ts, 10, 9)) ->super.getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 1, 14)) +>f1 : Symbol(f1, Decl(superPropertyAccess_ES6.ts, 9, 9)) +>super.getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 0, 14)) >super : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) ->getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 1, 14)) +>getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 0, 14)) const f2 = super.value; ->f2 : Symbol(f2, Decl(superPropertyAccess_ES6.ts, 11, 9)) ->super.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>f2 : Symbol(f2, Decl(superPropertyAccess_ES6.ts, 10, 9)) +>super.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) >super : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) ->value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) } } var d = new MyDerived(); ->d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 15, 3)) ->MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 4, 1)) +>d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 14, 3)) +>MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 3, 1)) var f3 = d.value; ->f3 : Symbol(f3, Decl(superPropertyAccess_ES6.ts, 16, 3)) ->d.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) ->d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 15, 3)) ->value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>f3 : Symbol(f3, Decl(superPropertyAccess_ES6.ts, 15, 3)) +>d.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) +>d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 14, 3)) +>value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) class A { ->A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) +>A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) private _property: string; ->_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) +>_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) get property() { return this._property; } ->property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) ->this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) ->_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) +>property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) +>this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) +>_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) set property(value: string) { this._property = value } ->property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 21, 17)) ->this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) ->this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) ->_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 21, 17)) +>property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 20, 17)) +>this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) +>this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) +>_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 20, 17)) } class B extends A { ->B : Symbol(B, Decl(superPropertyAccess_ES6.ts, 22, 1)) ->A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) +>B : Symbol(B, Decl(superPropertyAccess_ES6.ts, 21, 1)) +>A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) set property(value: string) { ->property : Symbol(B.property, Decl(superPropertyAccess_ES6.ts, 24, 19)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 25, 17)) +>property : Symbol(B.property, Decl(superPropertyAccess_ES6.ts, 23, 19)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 24, 17)) super.property = value + " addition"; ->super.property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->super : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) ->property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 25, 17)) +>super.property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>super : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) +>property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 24, 17)) } } diff --git a/tests/baselines/reference/superPropertyAccess_ES6.types b/tests/baselines/reference/superPropertyAccess_ES6.types index bb4082a73cf..c2457270ab8 100644 --- a/tests/baselines/reference/superPropertyAccess_ES6.types +++ b/tests/baselines/reference/superPropertyAccess_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/superPropertyAccess_ES6.ts === - class MyBase { >MyBase : MyBase diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.js b/tests/baselines/reference/superSymbolIndexedAccess2.js index bc42addc41f..9185dc76990 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.js +++ b/tests/baselines/reference/superSymbolIndexedAccess2.js @@ -1,5 +1,4 @@ //// [superSymbolIndexedAccess2.ts] - class Foo { [Symbol.isConcatSpreadable]() { return 0; diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.symbols b/tests/baselines/reference/superSymbolIndexedAccess2.symbols index 68b503778e7..1e10d3a9f94 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.symbols +++ b/tests/baselines/reference/superSymbolIndexedAccess2.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess2.ts === - class Foo { >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) @@ -13,7 +12,7 @@ class Foo { } class Bar extends Foo { ->Bar : Symbol(Bar, Decl(superSymbolIndexedAccess2.ts, 5, 1)) +>Bar : Symbol(Bar, Decl(superSymbolIndexedAccess2.ts, 4, 1)) >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) [Symbol.isConcatSpreadable]() { diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.types b/tests/baselines/reference/superSymbolIndexedAccess2.types index 61c760dfac7..3811c25f2fd 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.types +++ b/tests/baselines/reference/superSymbolIndexedAccess2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess2.ts === - class Foo { >Foo : Foo diff --git a/tests/baselines/reference/switchBreakStatements.errors.txt b/tests/baselines/reference/switchBreakStatements.errors.txt index 229c42068c3..904b504e668 100644 --- a/tests/baselines/reference/switchBreakStatements.errors.txt +++ b/tests/baselines/reference/switchBreakStatements.errors.txt @@ -1,18 +1,17 @@ -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(3,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(9,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(16,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(22,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(25,18): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(31,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(34,18): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(41,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(43,18): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(45,26): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(49,34): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(2,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(8,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(15,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(21,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(24,18): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(30,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(33,18): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(40,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(42,18): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(44,26): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(48,34): error TS2678: Type '"a"' is not comparable to type '""'. ==== tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts (11 errors) ==== - switch ('') { case 'a': ~~~ diff --git a/tests/baselines/reference/switchBreakStatements.js b/tests/baselines/reference/switchBreakStatements.js index d7fa279248c..534f025e2f5 100644 --- a/tests/baselines/reference/switchBreakStatements.js +++ b/tests/baselines/reference/switchBreakStatements.js @@ -1,5 +1,4 @@ //// [switchBreakStatements.ts] - switch ('') { case 'a': break; diff --git a/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt b/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt index d31a005842c..3aca9d926b7 100644 --- a/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt +++ b/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(19,10): error TS2678: Type '(number & true) | (number & false)' is not comparable to type 'string & number'. +tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(18,10): error TS2678: Type '(number & true) | (number & false)' is not comparable to type 'string & number'. Type 'number & false' is not comparable to type 'string & number'. Type 'number & false' is not comparable to type 'string'. -tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(23,10): error TS2678: Type 'boolean' is not comparable to type 'string & number'. +tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(22,10): error TS2678: Type 'boolean' is not comparable to type 'string & number'. ==== tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts (2 errors) ==== - var strAndNum: string & number; var numAndBool: number & boolean; var str: string; diff --git a/tests/baselines/reference/switchCaseWithIntersectionTypes01.js b/tests/baselines/reference/switchCaseWithIntersectionTypes01.js index 4e0ddf7ea76..b4bcc2519cd 100644 --- a/tests/baselines/reference/switchCaseWithIntersectionTypes01.js +++ b/tests/baselines/reference/switchCaseWithIntersectionTypes01.js @@ -1,5 +1,4 @@ //// [switchCaseWithIntersectionTypes01.ts] - var strAndNum: string & number; var numAndBool: number & boolean; var str: string; diff --git a/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt b/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt index 5f164f57343..40b5b419d1f 100644 --- a/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt +++ b/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithUnionTypes01.ts(23,10): error TS2678: Type 'boolean' is not comparable to type 'string | number'. +tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithUnionTypes01.ts(22,10): error TS2678: Type 'boolean' is not comparable to type 'string | number'. ==== tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithUnionTypes01.ts (1 errors) ==== - var strOrNum: string | number; var numOrBool: number | boolean; var str: string; diff --git a/tests/baselines/reference/switchCaseWithUnionTypes01.js b/tests/baselines/reference/switchCaseWithUnionTypes01.js index 5c34ea674dc..0c6aba224f6 100644 --- a/tests/baselines/reference/switchCaseWithUnionTypes01.js +++ b/tests/baselines/reference/switchCaseWithUnionTypes01.js @@ -1,5 +1,4 @@ //// [switchCaseWithUnionTypes01.ts] - var strOrNum: string | number; var numOrBool: number | boolean; var str: string; diff --git a/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt b/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt index c911886c670..9760ce4d99b 100644 --- a/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt +++ b/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(9,5): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. -tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(21,13): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. -tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(28,22): error TS1108: A 'return' statement can only be used within a function body. +tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(8,5): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. +tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(20,13): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. +tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(27,22): error TS1108: A 'return' statement can only be used within a function body. ==== tests/cases/compiler/switchStatementsWithMultipleDefaults.ts (3 errors) ==== - var x = 10; switch (x) { diff --git a/tests/baselines/reference/switchStatementsWithMultipleDefaults.js b/tests/baselines/reference/switchStatementsWithMultipleDefaults.js index a17abe5711d..e65e10a0c99 100644 --- a/tests/baselines/reference/switchStatementsWithMultipleDefaults.js +++ b/tests/baselines/reference/switchStatementsWithMultipleDefaults.js @@ -1,5 +1,4 @@ //// [switchStatementsWithMultipleDefaults.ts] - var x = 10; switch (x) { diff --git a/tests/baselines/reference/systemExportAssignment.js b/tests/baselines/reference/systemExportAssignment.js index 9db066ce8b1..8878da7b57b 100644 --- a/tests/baselines/reference/systemExportAssignment.js +++ b/tests/baselines/reference/systemExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemExportAssignment.ts] //// //// [a.d.ts] - declare var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/systemExportAssignment.symbols b/tests/baselines/reference/systemExportAssignment.symbols index 73346cdc4b8..40a7a1108da 100644 --- a/tests/baselines/reference/systemExportAssignment.symbols +++ b/tests/baselines/reference/systemExportAssignment.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) === tests/cases/compiler/b.ts === import * as a from "a"; diff --git a/tests/baselines/reference/systemExportAssignment.types b/tests/baselines/reference/systemExportAssignment.types index 84f896c301d..91901d68c48 100644 --- a/tests/baselines/reference/systemExportAssignment.types +++ b/tests/baselines/reference/systemExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; >a : number diff --git a/tests/baselines/reference/systemExportAssignment2.errors.txt b/tests/baselines/reference/systemExportAssignment2.errors.txt index 5606f8dd631..2e10f71bcc4 100644 --- a/tests/baselines/reference/systemExportAssignment2.errors.txt +++ b/tests/baselines/reference/systemExportAssignment2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(3,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. +tests/cases/compiler/a.ts(2,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 10; export = a; // Error: export = not allowed in ES6 ~~~~~~~~~~~ diff --git a/tests/baselines/reference/systemExportAssignment2.js b/tests/baselines/reference/systemExportAssignment2.js index a16724d9640..8c0698490fd 100644 --- a/tests/baselines/reference/systemExportAssignment2.js +++ b/tests/baselines/reference/systemExportAssignment2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemExportAssignment2.ts] //// //// [a.ts] - var a = 10; export = a; // Error: export = not allowed in ES6 diff --git a/tests/baselines/reference/systemExportAssignment3.js b/tests/baselines/reference/systemExportAssignment3.js index 00ebe2f50c9..5c59fdf21e4 100644 --- a/tests/baselines/reference/systemExportAssignment3.js +++ b/tests/baselines/reference/systemExportAssignment3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemExportAssignment3.ts] //// //// [modules.d.ts] - declare module "a" { var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/systemExportAssignment3.symbols b/tests/baselines/reference/systemExportAssignment3.symbols index 42d4a9d009f..099892c706e 100644 --- a/tests/baselines/reference/systemExportAssignment3.symbols +++ b/tests/baselines/reference/systemExportAssignment3.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) } === tests/cases/compiler/b.ts === diff --git a/tests/baselines/reference/systemExportAssignment3.types b/tests/baselines/reference/systemExportAssignment3.types index c32bc14ec90..e42fadc2944 100644 --- a/tests/baselines/reference/systemExportAssignment3.types +++ b/tests/baselines/reference/systemExportAssignment3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; >a : number diff --git a/tests/baselines/reference/systemModule1.js b/tests/baselines/reference/systemModule1.js index e2a4d309d66..4bd5ac09272 100644 --- a/tests/baselines/reference/systemModule1.js +++ b/tests/baselines/reference/systemModule1.js @@ -1,5 +1,4 @@ //// [systemModule1.ts] - export var x = 1; //// [systemModule1.js] diff --git a/tests/baselines/reference/systemModule1.symbols b/tests/baselines/reference/systemModule1.symbols index d6293c21fd9..1ef943671de 100644 --- a/tests/baselines/reference/systemModule1.symbols +++ b/tests/baselines/reference/systemModule1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule1.ts === - export var x = 1; ->x : Symbol(x, Decl(systemModule1.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule1.ts, 0, 10)) diff --git a/tests/baselines/reference/systemModule1.types b/tests/baselines/reference/systemModule1.types index 927b88f4b54..fd0d6554b3b 100644 --- a/tests/baselines/reference/systemModule1.types +++ b/tests/baselines/reference/systemModule1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule1.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/systemModule10.errors.txt b/tests/baselines/reference/systemModule10.errors.txt index 524e9bbe85d..e1548b30f90 100644 --- a/tests/baselines/reference/systemModule10.errors.txt +++ b/tests/baselines/reference/systemModule10.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/systemModule10.ts(2,20): error TS2307: Cannot find module 'file1'. -tests/cases/compiler/systemModule10.ts(3,21): error TS2307: Cannot find module 'file2'. +tests/cases/compiler/systemModule10.ts(1,20): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule10.ts(2,21): error TS2307: Cannot find module 'file2'. ==== tests/cases/compiler/systemModule10.ts (2 errors) ==== - import n, {x} from 'file1' ~~~~~~~ !!! error TS2307: Cannot find module 'file1'. diff --git a/tests/baselines/reference/systemModule10.js b/tests/baselines/reference/systemModule10.js index a54afee15d7..303e986dcc7 100644 --- a/tests/baselines/reference/systemModule10.js +++ b/tests/baselines/reference/systemModule10.js @@ -1,5 +1,4 @@ //// [systemModule10.ts] - import n, {x} from 'file1' import n2 = require('file2'); export {x} diff --git a/tests/baselines/reference/systemModule10_ES5.errors.txt b/tests/baselines/reference/systemModule10_ES5.errors.txt index 6f0e5305166..4a22dba31cd 100644 --- a/tests/baselines/reference/systemModule10_ES5.errors.txt +++ b/tests/baselines/reference/systemModule10_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/systemModule10_ES5.ts(2,20): error TS2307: Cannot find module 'file1'. -tests/cases/compiler/systemModule10_ES5.ts(3,21): error TS2307: Cannot find module 'file2'. +tests/cases/compiler/systemModule10_ES5.ts(1,20): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule10_ES5.ts(2,21): error TS2307: Cannot find module 'file2'. ==== tests/cases/compiler/systemModule10_ES5.ts (2 errors) ==== - import n, {x} from 'file1' ~~~~~~~ !!! error TS2307: Cannot find module 'file1'. diff --git a/tests/baselines/reference/systemModule10_ES5.js b/tests/baselines/reference/systemModule10_ES5.js index bac2a6003a4..f4339b4ac16 100644 --- a/tests/baselines/reference/systemModule10_ES5.js +++ b/tests/baselines/reference/systemModule10_ES5.js @@ -1,5 +1,4 @@ //// [systemModule10_ES5.ts] - import n, {x} from 'file1' import n2 = require('file2'); export {x} diff --git a/tests/baselines/reference/systemModule11.errors.txt b/tests/baselines/reference/systemModule11.errors.txt index ed8f036c14f..46a47cc9a93 100644 --- a/tests/baselines/reference/systemModule11.errors.txt +++ b/tests/baselines/reference/systemModule11.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/file1.ts(7,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/file2.ts(7,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/file3.ts(2,25): error TS2307: Cannot find module 'a'. -tests/cases/compiler/file3.ts(4,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/file4.ts(9,27): error TS2307: Cannot find module 'a'. -tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. +tests/cases/compiler/file1.ts(6,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/file2.ts(6,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/file3.ts(1,25): error TS2307: Cannot find module 'a'. +tests/cases/compiler/file3.ts(3,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/file4.ts(8,27): error TS2307: Cannot find module 'a'. +tests/cases/compiler/file5.ts(2,15): error TS2307: Cannot find module 'a'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - // set of tests cases that checks generation of local storage for exported names @@ -18,7 +17,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'bar'. ==== tests/cases/compiler/file2.ts (1 errors) ==== - var x; var y; export {x}; @@ -29,7 +27,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'bar'. ==== tests/cases/compiler/file3.ts (2 errors) ==== - export {x, y as z} from 'a'; ~~~ !!! error TS2307: Cannot find module 'a'. @@ -39,7 +36,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'bar'. ==== tests/cases/compiler/file4.ts (1 errors) ==== - export var x; export function foo() {} export default function (){} @@ -52,7 +48,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'a'. ==== tests/cases/compiler/file5.ts (1 errors) ==== - function foo() {} export * from 'a'; ~~~ diff --git a/tests/baselines/reference/systemModule11.js b/tests/baselines/reference/systemModule11.js index 212a24b5e20..b2d4d20bc8d 100644 --- a/tests/baselines/reference/systemModule11.js +++ b/tests/baselines/reference/systemModule11.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModule11.ts] //// //// [file1.ts] - // set of tests cases that checks generation of local storage for exported names @@ -10,7 +9,6 @@ export function foo() {} export * from 'bar'; //// [file2.ts] - var x; var y; export {x}; @@ -19,13 +17,11 @@ export {y as y1} export * from 'bar'; //// [file3.ts] - export {x, y as z} from 'a'; export default function foo() {} export * from 'bar'; //// [file4.ts] - export var x; export function foo() {} export default function (){} @@ -36,7 +32,6 @@ export {z, z1 as z2}; export {s, s1 as s2} from 'a' //// [file5.ts] - function foo() {} export * from 'a'; @@ -65,8 +60,7 @@ System.register(["bar"], function (exports_1, context_1) { exportStar_1(bar_1_1); } ], - execute: function () { - // set of tests cases that checks generation of local storage for exported names + execute: function () {// set of tests cases that checks generation of local storage for exported names } }; }); diff --git a/tests/baselines/reference/systemModule12.errors.txt b/tests/baselines/reference/systemModule12.errors.txt index 5c89e2e65d6..57de4e1f9a5 100644 --- a/tests/baselines/reference/systemModule12.errors.txt +++ b/tests/baselines/reference/systemModule12.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/systemModule12.ts(3,15): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule12.ts(2,15): error TS2307: Cannot find module 'file1'. ==== tests/cases/compiler/systemModule12.ts (1 errors) ==== - /// import n from 'file1' ~~~~~~~ diff --git a/tests/baselines/reference/systemModule12.js b/tests/baselines/reference/systemModule12.js index 8e94ffb54da..272e1349c1a 100644 --- a/tests/baselines/reference/systemModule12.js +++ b/tests/baselines/reference/systemModule12.js @@ -1,5 +1,4 @@ //// [systemModule12.ts] - /// import n from 'file1' diff --git a/tests/baselines/reference/systemModule13.js b/tests/baselines/reference/systemModule13.js index d3fee049e04..78b1c6cd867 100644 --- a/tests/baselines/reference/systemModule13.js +++ b/tests/baselines/reference/systemModule13.js @@ -1,5 +1,4 @@ //// [systemModule13.ts] - export let [x,y,z] = [1, 2, 3]; export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; for ([x] of [[1]]) {} diff --git a/tests/baselines/reference/systemModule13.symbols b/tests/baselines/reference/systemModule13.symbols index 8245029e006..3af3b6868ab 100644 --- a/tests/baselines/reference/systemModule13.symbols +++ b/tests/baselines/reference/systemModule13.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/systemModule13.ts === - export let [x,y,z] = [1, 2, 3]; ->x : Symbol(x, Decl(systemModule13.ts, 1, 12)) ->y : Symbol(y, Decl(systemModule13.ts, 1, 14)) ->z : Symbol(z, Decl(systemModule13.ts, 1, 16)) +>x : Symbol(x, Decl(systemModule13.ts, 0, 12)) +>y : Symbol(y, Decl(systemModule13.ts, 0, 14)) +>z : Symbol(z, Decl(systemModule13.ts, 0, 16)) export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; ->a : Symbol(a, Decl(systemModule13.ts, 2, 36)) ->z0 : Symbol(z0, Decl(systemModule13.ts, 2, 14)) ->b : Symbol(b, Decl(systemModule13.ts, 2, 44)) ->c : Symbol(c, Decl(systemModule13.ts, 2, 49)) ->z1 : Symbol(z1, Decl(systemModule13.ts, 2, 25)) ->a : Symbol(a, Decl(systemModule13.ts, 2, 36)) ->b : Symbol(b, Decl(systemModule13.ts, 2, 44)) ->c : Symbol(c, Decl(systemModule13.ts, 2, 49)) +>a : Symbol(a, Decl(systemModule13.ts, 1, 36)) +>z0 : Symbol(z0, Decl(systemModule13.ts, 1, 14)) +>b : Symbol(b, Decl(systemModule13.ts, 1, 44)) +>c : Symbol(c, Decl(systemModule13.ts, 1, 49)) +>z1 : Symbol(z1, Decl(systemModule13.ts, 1, 25)) +>a : Symbol(a, Decl(systemModule13.ts, 1, 36)) +>b : Symbol(b, Decl(systemModule13.ts, 1, 44)) +>c : Symbol(c, Decl(systemModule13.ts, 1, 49)) for ([x] of [[1]]) {} ->x : Symbol(x, Decl(systemModule13.ts, 1, 12)) +>x : Symbol(x, Decl(systemModule13.ts, 0, 12)) diff --git a/tests/baselines/reference/systemModule13.types b/tests/baselines/reference/systemModule13.types index ec85746d2bb..0015c6c942e 100644 --- a/tests/baselines/reference/systemModule13.types +++ b/tests/baselines/reference/systemModule13.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule13.ts === - export let [x,y,z] = [1, 2, 3]; >x : number >y : number diff --git a/tests/baselines/reference/systemModule14.errors.txt b/tests/baselines/reference/systemModule14.errors.txt index 6ba64896df8..a1555fdab32 100644 --- a/tests/baselines/reference/systemModule14.errors.txt +++ b/tests/baselines/reference/systemModule14.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/systemModule14.ts(6,17): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule14.ts(5,17): error TS2307: Cannot find module 'foo'. ==== tests/cases/compiler/systemModule14.ts (1 errors) ==== - function foo() { return a; } diff --git a/tests/baselines/reference/systemModule14.js b/tests/baselines/reference/systemModule14.js index ba4adc7aabc..9f0c8f1ac03 100644 --- a/tests/baselines/reference/systemModule14.js +++ b/tests/baselines/reference/systemModule14.js @@ -1,5 +1,4 @@ //// [systemModule14.ts] - function foo() { return a; } diff --git a/tests/baselines/reference/systemModule15.js b/tests/baselines/reference/systemModule15.js index 92f9bf444bd..0db82701a01 100644 --- a/tests/baselines/reference/systemModule15.js +++ b/tests/baselines/reference/systemModule15.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/systemModule15.ts] //// //// [file1.ts] - - import * as moduleB from "./file2" declare function use(v: any): void; @@ -12,7 +10,6 @@ use(moduleB.moduleC); use(moduleB.moduleCStar); //// [file2.ts] - import * as moduleCStar from "./file3" import {value2} from "./file4" import moduleC from "./file3" @@ -25,12 +22,10 @@ export { } //// [file3.ts] - export var value = "youpi"; export default value; //// [file4.ts] - export var value2 = "v"; //// [file3.js] diff --git a/tests/baselines/reference/systemModule15.symbols b/tests/baselines/reference/systemModule15.symbols index 2572950a7f2..f3fc4b39f74 100644 --- a/tests/baselines/reference/systemModule15.symbols +++ b/tests/baselines/reference/systemModule15.symbols @@ -1,66 +1,61 @@ === tests/cases/compiler/file1.ts === - - import * as moduleB from "./file2" ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) declare function use(v: any): void; ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->v : Symbol(v, Decl(file1.ts, 4, 21)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>v : Symbol(v, Decl(file1.ts, 2, 21)) use(moduleB.value); ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->moduleB.value : Symbol(moduleB.value, Decl(file2.ts, 8, 12)) ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) ->value : Symbol(moduleB.value, Decl(file2.ts, 8, 12)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>moduleB.value : Symbol(moduleB.value, Decl(file2.ts, 7, 12)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) +>value : Symbol(moduleB.value, Decl(file2.ts, 7, 12)) use(moduleB.moduleC); ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->moduleB.moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 7, 16)) ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) ->moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 7, 16)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>moduleB.moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 6, 16)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) +>moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 6, 16)) use(moduleB.moduleCStar); ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->moduleB.moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 6, 8)) ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) ->moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 6, 8)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>moduleB.moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 5, 8)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) +>moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 5, 8)) === tests/cases/compiler/file2.ts === - import * as moduleCStar from "./file3" ->moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 1, 6)) +>moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 0, 6)) import {value2} from "./file4" ->value2 : Symbol(value2, Decl(file2.ts, 2, 8)) +>value2 : Symbol(value2, Decl(file2.ts, 1, 8)) import moduleC from "./file3" ->moduleC : Symbol(moduleC, Decl(file2.ts, 3, 6)) +>moduleC : Symbol(moduleC, Decl(file2.ts, 2, 6)) import {value} from "./file3" ->value : Symbol(value, Decl(file2.ts, 4, 8)) +>value : Symbol(value, Decl(file2.ts, 3, 8)) export { moduleCStar, ->moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 6, 8)) +>moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 5, 8)) moduleC, ->moduleC : Symbol(moduleC, Decl(file2.ts, 7, 16)) +>moduleC : Symbol(moduleC, Decl(file2.ts, 6, 16)) value ->value : Symbol(value, Decl(file2.ts, 8, 12)) +>value : Symbol(value, Decl(file2.ts, 7, 12)) } === tests/cases/compiler/file3.ts === - export var value = "youpi"; ->value : Symbol(value, Decl(file3.ts, 1, 10)) +>value : Symbol(value, Decl(file3.ts, 0, 10)) export default value; ->value : Symbol(value, Decl(file3.ts, 1, 10)) +>value : Symbol(value, Decl(file3.ts, 0, 10)) === tests/cases/compiler/file4.ts === - export var value2 = "v"; ->value2 : Symbol(value2, Decl(file4.ts, 1, 10)) +>value2 : Symbol(value2, Decl(file4.ts, 0, 10)) diff --git a/tests/baselines/reference/systemModule15.types b/tests/baselines/reference/systemModule15.types index 7ebd1f7378e..747583323ad 100644 --- a/tests/baselines/reference/systemModule15.types +++ b/tests/baselines/reference/systemModule15.types @@ -1,6 +1,4 @@ === tests/cases/compiler/file1.ts === - - import * as moduleB from "./file2" >moduleB : typeof moduleB @@ -30,7 +28,6 @@ use(moduleB.moduleCStar); >moduleCStar : typeof "tests/cases/compiler/file3" === tests/cases/compiler/file2.ts === - import * as moduleCStar from "./file3" >moduleCStar : typeof moduleCStar @@ -55,7 +52,6 @@ export { } === tests/cases/compiler/file3.ts === - export var value = "youpi"; >value : string >"youpi" : "youpi" @@ -64,7 +60,6 @@ export default value; >value : string === tests/cases/compiler/file4.ts === - export var value2 = "v"; >value2 : string >"v" : "v" diff --git a/tests/baselines/reference/systemModule16.errors.txt b/tests/baselines/reference/systemModule16.errors.txt index 33d7ba58bc2..6e65f7e31a1 100644 --- a/tests/baselines/reference/systemModule16.errors.txt +++ b/tests/baselines/reference/systemModule16.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/systemModule16.ts(2,20): error TS2307: Cannot find module 'foo'. -tests/cases/compiler/systemModule16.ts(3,20): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/systemModule16.ts(4,15): error TS2307: Cannot find module 'foo'. -tests/cases/compiler/systemModule16.ts(5,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/systemModule16.ts(8,32): error TS2307: Cannot find module 'foo'. -tests/cases/compiler/systemModule16.ts(9,32): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(1,20): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule16.ts(2,20): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/systemModule16.ts(3,15): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule16.ts(4,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/systemModule16.ts(7,32): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule16.ts(8,32): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. ==== tests/cases/compiler/systemModule16.ts (10 errors) ==== - import * as x from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/systemModule16.js b/tests/baselines/reference/systemModule16.js index 86b6a448215..8e912d3c63c 100644 --- a/tests/baselines/reference/systemModule16.js +++ b/tests/baselines/reference/systemModule16.js @@ -1,5 +1,4 @@ //// [systemModule16.ts] - import * as x from "foo"; import * as y from "bar"; export * from "foo"; diff --git a/tests/baselines/reference/systemModule17.js b/tests/baselines/reference/systemModule17.js index bcdf6612356..bab203d8aa2 100644 --- a/tests/baselines/reference/systemModule17.js +++ b/tests/baselines/reference/systemModule17.js @@ -1,13 +1,10 @@ //// [tests/cases/compiler/systemModule17.ts] //// //// [f1.ts] - - export class A {} export interface I {} //// [f2.ts] - var x = 1; interface I { } diff --git a/tests/baselines/reference/systemModule17.symbols b/tests/baselines/reference/systemModule17.symbols index 3bf19dad950..358ef26542c 100644 --- a/tests/baselines/reference/systemModule17.symbols +++ b/tests/baselines/reference/systemModule17.symbols @@ -1,93 +1,90 @@ === tests/cases/compiler/f1.ts === - - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0)) export interface I {} ->I : Symbol(I, Decl(f1.ts, 2, 17)) +>I : Symbol(I, Decl(f1.ts, 0, 17)) === tests/cases/compiler/f2.ts === - var x = 1; ->x : Symbol(x, Decl(f2.ts, 1, 3)) +>x : Symbol(x, Decl(f2.ts, 0, 3)) interface I { } ->I : Symbol(I, Decl(f2.ts, 1, 10)) +>I : Symbol(I, Decl(f2.ts, 0, 10)) namespace N { ->N : Symbol(N, Decl(f2.ts, 2, 15)) +>N : Symbol(N, Decl(f2.ts, 1, 15)) export var x = 1; ->x : Symbol(x, Decl(f2.ts, 5, 11)) +>x : Symbol(x, Decl(f2.ts, 4, 11)) export interface I { } ->I : Symbol(I, Decl(f2.ts, 5, 18)) +>I : Symbol(I, Decl(f2.ts, 4, 18)) } import IX = N.x; ->IX : Symbol(IX, Decl(f2.ts, 7, 1)) ->N : Symbol(N, Decl(f2.ts, 2, 15)) ->x : Symbol(IX, Decl(f2.ts, 5, 11)) +>IX : Symbol(IX, Decl(f2.ts, 6, 1)) +>N : Symbol(N, Decl(f2.ts, 1, 15)) +>x : Symbol(IX, Decl(f2.ts, 4, 11)) import II = N.I; ->II : Symbol(II, Decl(f2.ts, 9, 16)) ->N : Symbol(N, Decl(f2.ts, 2, 15)) ->I : Symbol(II, Decl(f2.ts, 5, 18)) +>II : Symbol(II, Decl(f2.ts, 8, 16)) +>N : Symbol(N, Decl(f2.ts, 1, 15)) +>I : Symbol(II, Decl(f2.ts, 4, 18)) import { A, A as EA, I as EI } from "f1"; ->A : Symbol(A, Decl(f2.ts, 11, 8)) ->A : Symbol(EA, Decl(f2.ts, 11, 11)) ->EA : Symbol(EA, Decl(f2.ts, 11, 11)) ->I : Symbol(EI, Decl(f2.ts, 11, 20)) ->EI : Symbol(EI, Decl(f2.ts, 11, 20)) +>A : Symbol(A, Decl(f2.ts, 10, 8)) +>A : Symbol(EA, Decl(f2.ts, 10, 11)) +>EA : Symbol(EA, Decl(f2.ts, 10, 11)) +>I : Symbol(EI, Decl(f2.ts, 10, 20)) +>EI : Symbol(EI, Decl(f2.ts, 10, 20)) export {x}; ->x : Symbol(x, Decl(f2.ts, 13, 8)) +>x : Symbol(x, Decl(f2.ts, 12, 8)) export {x as x1}; ->x : Symbol(x1, Decl(f2.ts, 14, 8)) ->x1 : Symbol(x1, Decl(f2.ts, 14, 8)) +>x : Symbol(x1, Decl(f2.ts, 13, 8)) +>x1 : Symbol(x1, Decl(f2.ts, 13, 8)) export {I}; ->I : Symbol(I, Decl(f2.ts, 16, 8)) +>I : Symbol(I, Decl(f2.ts, 15, 8)) export {I as I1}; ->I : Symbol(I1, Decl(f2.ts, 17, 8)) ->I1 : Symbol(I1, Decl(f2.ts, 17, 8)) +>I : Symbol(I1, Decl(f2.ts, 16, 8)) +>I1 : Symbol(I1, Decl(f2.ts, 16, 8)) export {A}; ->A : Symbol(A, Decl(f2.ts, 19, 8)) +>A : Symbol(A, Decl(f2.ts, 18, 8)) export {A as A1}; ->A : Symbol(A1, Decl(f2.ts, 20, 8)) ->A1 : Symbol(A1, Decl(f2.ts, 20, 8)) +>A : Symbol(A1, Decl(f2.ts, 19, 8)) +>A1 : Symbol(A1, Decl(f2.ts, 19, 8)) export {EA}; ->EA : Symbol(EA, Decl(f2.ts, 22, 8)) +>EA : Symbol(EA, Decl(f2.ts, 21, 8)) export {EA as EA1}; ->EA : Symbol(EA1, Decl(f2.ts, 23, 8)) ->EA1 : Symbol(EA1, Decl(f2.ts, 23, 8)) +>EA : Symbol(EA1, Decl(f2.ts, 22, 8)) +>EA1 : Symbol(EA1, Decl(f2.ts, 22, 8)) export {EI }; ->EI : Symbol(EI, Decl(f2.ts, 25, 8)) +>EI : Symbol(EI, Decl(f2.ts, 24, 8)) export {EI as EI1}; ->EI : Symbol(EI1, Decl(f2.ts, 26, 8)) ->EI1 : Symbol(EI1, Decl(f2.ts, 26, 8)) +>EI : Symbol(EI1, Decl(f2.ts, 25, 8)) +>EI1 : Symbol(EI1, Decl(f2.ts, 25, 8)) export {IX}; ->IX : Symbol(IX, Decl(f2.ts, 28, 8)) +>IX : Symbol(IX, Decl(f2.ts, 27, 8)) export {IX as IX1}; ->IX : Symbol(IX1, Decl(f2.ts, 29, 8)) ->IX1 : Symbol(IX1, Decl(f2.ts, 29, 8)) +>IX : Symbol(IX1, Decl(f2.ts, 28, 8)) +>IX1 : Symbol(IX1, Decl(f2.ts, 28, 8)) export {II}; ->II : Symbol(II, Decl(f2.ts, 31, 8)) +>II : Symbol(II, Decl(f2.ts, 30, 8)) export {II as II1}; ->II : Symbol(II1, Decl(f2.ts, 32, 8)) ->II1 : Symbol(II1, Decl(f2.ts, 32, 8)) +>II : Symbol(II1, Decl(f2.ts, 31, 8)) +>II1 : Symbol(II1, Decl(f2.ts, 31, 8)) diff --git a/tests/baselines/reference/systemModule17.types b/tests/baselines/reference/systemModule17.types index c0a0a7dc584..7819ddd7e32 100644 --- a/tests/baselines/reference/systemModule17.types +++ b/tests/baselines/reference/systemModule17.types @@ -1,6 +1,4 @@ === tests/cases/compiler/f1.ts === - - export class A {} >A : A @@ -8,7 +6,6 @@ export interface I {} >I : I === tests/cases/compiler/f2.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/systemModule2.errors.txt b/tests/baselines/reference/systemModule2.errors.txt index e323e2cde2e..2c79d6434b4 100644 --- a/tests/baselines/reference/systemModule2.errors.txt +++ b/tests/baselines/reference/systemModule2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/systemModule2.ts(3,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. +tests/cases/compiler/systemModule2.ts(2,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. ==== tests/cases/compiler/systemModule2.ts (1 errors) ==== - var x = 1; export = x; ~~~~~~~~~~~ diff --git a/tests/baselines/reference/systemModule2.js b/tests/baselines/reference/systemModule2.js index c267eaefb43..1180d9e3dc9 100644 --- a/tests/baselines/reference/systemModule2.js +++ b/tests/baselines/reference/systemModule2.js @@ -1,5 +1,4 @@ //// [systemModule2.ts] - var x = 1; export = x; diff --git a/tests/baselines/reference/systemModule3.js b/tests/baselines/reference/systemModule3.js index 109cbb7187c..b7a91ac5d4a 100644 --- a/tests/baselines/reference/systemModule3.js +++ b/tests/baselines/reference/systemModule3.js @@ -1,20 +1,15 @@ //// [tests/cases/compiler/systemModule3.ts] //// //// [file1.ts] - - export default function() {} //// [file2.ts] - export default function f() {} //// [file3.ts] - export default class C {} //// [file4.ts] - export default class {} //// [file1.js] diff --git a/tests/baselines/reference/systemModule3.symbols b/tests/baselines/reference/systemModule3.symbols index a8f8ab46915..a8226acebdc 100644 --- a/tests/baselines/reference/systemModule3.symbols +++ b/tests/baselines/reference/systemModule3.symbols @@ -1,19 +1,14 @@ === tests/cases/compiler/file1.ts === - -No type information for this code. -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === - export default function f() {} >f : Symbol(f, Decl(file2.ts, 0, 0)) === tests/cases/compiler/file3.ts === - export default class C {} >C : Symbol(C, Decl(file3.ts, 0, 0)) === tests/cases/compiler/file4.ts === - -No type information for this code.export default class {} +export default class {} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/systemModule3.types b/tests/baselines/reference/systemModule3.types index 4448588b74c..691f5bdaaf0 100644 --- a/tests/baselines/reference/systemModule3.types +++ b/tests/baselines/reference/systemModule3.types @@ -1,19 +1,14 @@ === tests/cases/compiler/file1.ts === - -No type information for this code. -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === - export default function f() {} >f : () => void === tests/cases/compiler/file3.ts === - export default class C {} >C : C === tests/cases/compiler/file4.ts === - -No type information for this code.export default class {} +export default class {} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/systemModule4.js b/tests/baselines/reference/systemModule4.js index 22a4755e9fb..9b59265f832 100644 --- a/tests/baselines/reference/systemModule4.js +++ b/tests/baselines/reference/systemModule4.js @@ -1,5 +1,4 @@ //// [systemModule4.ts] - export var x = 1; export var y; diff --git a/tests/baselines/reference/systemModule4.symbols b/tests/baselines/reference/systemModule4.symbols index b0bc1a1cfc1..c90c35de201 100644 --- a/tests/baselines/reference/systemModule4.symbols +++ b/tests/baselines/reference/systemModule4.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/systemModule4.ts === - export var x = 1; ->x : Symbol(x, Decl(systemModule4.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule4.ts, 0, 10)) export var y; ->y : Symbol(y, Decl(systemModule4.ts, 2, 10)) +>y : Symbol(y, Decl(systemModule4.ts, 1, 10)) diff --git a/tests/baselines/reference/systemModule4.types b/tests/baselines/reference/systemModule4.types index 8a871a987a7..4568dd053a8 100644 --- a/tests/baselines/reference/systemModule4.types +++ b/tests/baselines/reference/systemModule4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule4.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/systemModule5.js b/tests/baselines/reference/systemModule5.js index ada3b339168..a1e8de3e82c 100644 --- a/tests/baselines/reference/systemModule5.js +++ b/tests/baselines/reference/systemModule5.js @@ -1,5 +1,4 @@ //// [systemModule5.ts] - export function foo() {} diff --git a/tests/baselines/reference/systemModule5.symbols b/tests/baselines/reference/systemModule5.symbols index b2f896dd183..fb760600b30 100644 --- a/tests/baselines/reference/systemModule5.symbols +++ b/tests/baselines/reference/systemModule5.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule5.ts === - export function foo() {} >foo : Symbol(foo, Decl(systemModule5.ts, 0, 0)) diff --git a/tests/baselines/reference/systemModule5.types b/tests/baselines/reference/systemModule5.types index 0061f002801..91d88f04fb0 100644 --- a/tests/baselines/reference/systemModule5.types +++ b/tests/baselines/reference/systemModule5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule5.ts === - export function foo() {} >foo : () => void diff --git a/tests/baselines/reference/systemModule6.js b/tests/baselines/reference/systemModule6.js index 5e1f51dd697..3632881127a 100644 --- a/tests/baselines/reference/systemModule6.js +++ b/tests/baselines/reference/systemModule6.js @@ -1,5 +1,4 @@ //// [systemModule6.ts] - export class C {} function foo() { new C(); diff --git a/tests/baselines/reference/systemModule6.symbols b/tests/baselines/reference/systemModule6.symbols index e01d276559a..4cf8ad81039 100644 --- a/tests/baselines/reference/systemModule6.symbols +++ b/tests/baselines/reference/systemModule6.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/systemModule6.ts === - export class C {} >C : Symbol(C, Decl(systemModule6.ts, 0, 0)) function foo() { ->foo : Symbol(foo, Decl(systemModule6.ts, 1, 17)) +>foo : Symbol(foo, Decl(systemModule6.ts, 0, 17)) new C(); >C : Symbol(C, Decl(systemModule6.ts, 0, 0)) diff --git a/tests/baselines/reference/systemModule6.types b/tests/baselines/reference/systemModule6.types index cc8a97c066e..31a445e5732 100644 --- a/tests/baselines/reference/systemModule6.types +++ b/tests/baselines/reference/systemModule6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule6.ts === - export class C {} >C : C diff --git a/tests/baselines/reference/systemModule7.js b/tests/baselines/reference/systemModule7.js index d25ca627e44..970195379f4 100644 --- a/tests/baselines/reference/systemModule7.js +++ b/tests/baselines/reference/systemModule7.js @@ -1,5 +1,4 @@ //// [systemModule7.ts] - // filename: instantiatedModule.ts export module M { var x = 1; diff --git a/tests/baselines/reference/systemModule7.symbols b/tests/baselines/reference/systemModule7.symbols index e47ab5510b5..4f5c4a127bc 100644 --- a/tests/baselines/reference/systemModule7.symbols +++ b/tests/baselines/reference/systemModule7.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/systemModule7.ts === - // filename: instantiatedModule.ts export module M { ->M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 4, 1)) +>M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 3, 1)) var x = 1; ->x : Symbol(x, Decl(systemModule7.ts, 3, 7)) +>x : Symbol(x, Decl(systemModule7.ts, 2, 7)) } // filename: nonInstantiatedModule.ts export module M { ->M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 4, 1)) +>M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 3, 1)) interface I {} ->I : Symbol(I, Decl(systemModule7.ts, 7, 17)) +>I : Symbol(I, Decl(systemModule7.ts, 6, 17)) } diff --git a/tests/baselines/reference/systemModule7.types b/tests/baselines/reference/systemModule7.types index 33003f5fa37..ec39957501f 100644 --- a/tests/baselines/reference/systemModule7.types +++ b/tests/baselines/reference/systemModule7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule7.ts === - // filename: instantiatedModule.ts export module M { >M : typeof M diff --git a/tests/baselines/reference/systemModule8.js b/tests/baselines/reference/systemModule8.js index 3065d4f35b3..af029967a99 100644 --- a/tests/baselines/reference/systemModule8.js +++ b/tests/baselines/reference/systemModule8.js @@ -1,5 +1,4 @@ //// [systemModule8.ts] - export var x; x = 1; x++; diff --git a/tests/baselines/reference/systemModule8.symbols b/tests/baselines/reference/systemModule8.symbols index 719d48e4592..d611f74dbc6 100644 --- a/tests/baselines/reference/systemModule8.symbols +++ b/tests/baselines/reference/systemModule8.symbols @@ -1,92 +1,91 @@ === tests/cases/compiler/systemModule8.ts === - export var x; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x = 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x++; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x--; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) ++x; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) --x; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x += 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x -= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x *= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x /= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x |= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x &= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x + 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x - 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x & 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x | 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 5;;x++) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 8;;x--) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 15;;++x) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 18;;--x) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (let x = 50;;) {} ->x : Symbol(x, Decl(systemModule8.ts, 22, 8)) +>x : Symbol(x, Decl(systemModule8.ts, 21, 8)) function foo() { ->foo : Symbol(foo, Decl(systemModule8.ts, 22, 21)) +>foo : Symbol(foo, Decl(systemModule8.ts, 21, 21)) x = 100; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) } export let [y] = [1]; ->y : Symbol(y, Decl(systemModule8.ts, 27, 12)) +>y : Symbol(y, Decl(systemModule8.ts, 26, 12)) export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; ->a : Symbol(a, Decl(systemModule8.ts, 28, 36)) ->z0 : Symbol(z0, Decl(systemModule8.ts, 28, 14)) ->b : Symbol(b, Decl(systemModule8.ts, 28, 44)) ->c : Symbol(c, Decl(systemModule8.ts, 28, 49)) ->z1 : Symbol(z1, Decl(systemModule8.ts, 28, 25)) ->a : Symbol(a, Decl(systemModule8.ts, 28, 36)) ->b : Symbol(b, Decl(systemModule8.ts, 28, 44)) ->c : Symbol(c, Decl(systemModule8.ts, 28, 49)) +>a : Symbol(a, Decl(systemModule8.ts, 27, 36)) +>z0 : Symbol(z0, Decl(systemModule8.ts, 27, 14)) +>b : Symbol(b, Decl(systemModule8.ts, 27, 44)) +>c : Symbol(c, Decl(systemModule8.ts, 27, 49)) +>z1 : Symbol(z1, Decl(systemModule8.ts, 27, 25)) +>a : Symbol(a, Decl(systemModule8.ts, 27, 36)) +>b : Symbol(b, Decl(systemModule8.ts, 27, 44)) +>c : Symbol(c, Decl(systemModule8.ts, 27, 49)) for ([x] of [[1]]) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) diff --git a/tests/baselines/reference/systemModule8.types b/tests/baselines/reference/systemModule8.types index f31e77c346d..01d9b094165 100644 --- a/tests/baselines/reference/systemModule8.types +++ b/tests/baselines/reference/systemModule8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule8.ts === - export var x; >x : any diff --git a/tests/baselines/reference/systemModule9.errors.txt b/tests/baselines/reference/systemModule9.errors.txt index 27af70cce6a..bedcc561058 100644 --- a/tests/baselines/reference/systemModule9.errors.txt +++ b/tests/baselines/reference/systemModule9.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/systemModule9.ts(2,21): error TS2307: Cannot find module 'file1'. -tests/cases/compiler/systemModule9.ts(3,25): error TS2307: Cannot find module 'file2'. -tests/cases/compiler/systemModule9.ts(4,15): error TS2307: Cannot find module 'file3'. -tests/cases/compiler/systemModule9.ts(6,25): error TS2307: Cannot find module 'file5'. -tests/cases/compiler/systemModule9.ts(7,22): error TS2307: Cannot find module 'file6'. -tests/cases/compiler/systemModule9.ts(17,15): error TS2307: Cannot find module 'file7'. +tests/cases/compiler/systemModule9.ts(1,21): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule9.ts(2,25): error TS2307: Cannot find module 'file2'. +tests/cases/compiler/systemModule9.ts(3,15): error TS2307: Cannot find module 'file3'. +tests/cases/compiler/systemModule9.ts(5,25): error TS2307: Cannot find module 'file5'. +tests/cases/compiler/systemModule9.ts(6,22): error TS2307: Cannot find module 'file6'. +tests/cases/compiler/systemModule9.ts(16,15): error TS2307: Cannot find module 'file7'. ==== tests/cases/compiler/systemModule9.ts (6 errors) ==== - import * as ns from 'file1'; ~~~~~~~ !!! error TS2307: Cannot find module 'file1'. diff --git a/tests/baselines/reference/systemModule9.js b/tests/baselines/reference/systemModule9.js index fce3aa1bdf4..b83d62f9cf8 100644 --- a/tests/baselines/reference/systemModule9.js +++ b/tests/baselines/reference/systemModule9.js @@ -1,5 +1,4 @@ //// [systemModule9.ts] - import * as ns from 'file1'; import {a, b as c} from 'file2'; import d from 'file3' diff --git a/tests/baselines/reference/systemModuleAmbientDeclarations.js b/tests/baselines/reference/systemModuleAmbientDeclarations.js index 9714f138c5e..45a484be44d 100644 --- a/tests/baselines/reference/systemModuleAmbientDeclarations.js +++ b/tests/baselines/reference/systemModuleAmbientDeclarations.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModuleAmbientDeclarations.ts] //// //// [file1.ts] - declare class Promise { } declare function Foo(): void; declare class C {} diff --git a/tests/baselines/reference/systemModuleAmbientDeclarations.symbols b/tests/baselines/reference/systemModuleAmbientDeclarations.symbols index c2e8557270b..5143731caf0 100644 --- a/tests/baselines/reference/systemModuleAmbientDeclarations.symbols +++ b/tests/baselines/reference/systemModuleAmbientDeclarations.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/file1.ts === - declare class Promise { } >Promise : Symbol(Promise, Decl(file1.ts, 0, 0)) declare function Foo(): void; ->Foo : Symbol(Foo, Decl(file1.ts, 1, 25)) +>Foo : Symbol(Foo, Decl(file1.ts, 0, 25)) declare class C {} ->C : Symbol(C, Decl(file1.ts, 2, 29)) +>C : Symbol(C, Decl(file1.ts, 1, 29)) declare enum E {X = 1}; ->E : Symbol(E, Decl(file1.ts, 3, 18)) ->X : Symbol(E.X, Decl(file1.ts, 4, 16)) +>E : Symbol(E, Decl(file1.ts, 2, 18)) +>X : Symbol(E.X, Decl(file1.ts, 3, 16)) export var promise = Promise; ->promise : Symbol(promise, Decl(file1.ts, 6, 10)) +>promise : Symbol(promise, Decl(file1.ts, 5, 10)) >Promise : Symbol(Promise, Decl(file1.ts, 0, 0)) export var foo = Foo; ->foo : Symbol(foo, Decl(file1.ts, 7, 10)) ->Foo : Symbol(Foo, Decl(file1.ts, 1, 25)) +>foo : Symbol(foo, Decl(file1.ts, 6, 10)) +>Foo : Symbol(Foo, Decl(file1.ts, 0, 25)) export var c = C; ->c : Symbol(c, Decl(file1.ts, 8, 10)) ->C : Symbol(C, Decl(file1.ts, 2, 29)) +>c : Symbol(c, Decl(file1.ts, 7, 10)) +>C : Symbol(C, Decl(file1.ts, 1, 29)) export var e = E; ->e : Symbol(e, Decl(file1.ts, 9, 10)) ->E : Symbol(E, Decl(file1.ts, 3, 18)) +>e : Symbol(e, Decl(file1.ts, 8, 10)) +>E : Symbol(E, Decl(file1.ts, 2, 18)) === tests/cases/compiler/file2.ts === export declare function foo(); diff --git a/tests/baselines/reference/systemModuleAmbientDeclarations.types b/tests/baselines/reference/systemModuleAmbientDeclarations.types index 04c4f2d49df..83a1bb857c7 100644 --- a/tests/baselines/reference/systemModuleAmbientDeclarations.types +++ b/tests/baselines/reference/systemModuleAmbientDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - declare class Promise { } >Promise : Promise diff --git a/tests/baselines/reference/systemModuleConstEnums.js b/tests/baselines/reference/systemModuleConstEnums.js index dbb88c61e14..d99d3b22d44 100644 --- a/tests/baselines/reference/systemModuleConstEnums.js +++ b/tests/baselines/reference/systemModuleConstEnums.js @@ -1,5 +1,4 @@ //// [systemModuleConstEnums.ts] - declare function use(a: any); const enum TopLevelConstEnum { X } diff --git a/tests/baselines/reference/systemModuleConstEnums.symbols b/tests/baselines/reference/systemModuleConstEnums.symbols index 171f24628ec..7ebb52d3909 100644 --- a/tests/baselines/reference/systemModuleConstEnums.symbols +++ b/tests/baselines/reference/systemModuleConstEnums.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/systemModuleConstEnums.ts === - declare function use(a: any); >use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0)) ->a : Symbol(a, Decl(systemModuleConstEnums.ts, 1, 21)) +>a : Symbol(a, Decl(systemModuleConstEnums.ts, 0, 21)) const enum TopLevelConstEnum { X } ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 1, 30)) export function foo() { ->foo : Symbol(foo, Decl(systemModuleConstEnums.ts, 2, 34)) +>foo : Symbol(foo, Decl(systemModuleConstEnums.ts, 1, 34)) use(TopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0)) ->TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30)) ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30)) +>TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 1, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 1, 30)) use(M.NonTopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0)) ->M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44)) ->M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10)) ->M : Symbol(M, Decl(systemModuleConstEnums.ts, 7, 1)) ->NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10)) ->X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44)) +>M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 9, 44)) +>M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 8, 10)) +>M : Symbol(M, Decl(systemModuleConstEnums.ts, 6, 1)) +>NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 8, 10)) +>X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 9, 44)) } module M { ->M : Symbol(M, Decl(systemModuleConstEnums.ts, 7, 1)) +>M : Symbol(M, Decl(systemModuleConstEnums.ts, 6, 1)) export const enum NonTopLevelConstEnum { X } ->NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10)) ->X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44)) +>NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 8, 10)) +>X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 9, 44)) } diff --git a/tests/baselines/reference/systemModuleConstEnums.types b/tests/baselines/reference/systemModuleConstEnums.types index 193de0da3ab..08edfd24b28 100644 --- a/tests/baselines/reference/systemModuleConstEnums.types +++ b/tests/baselines/reference/systemModuleConstEnums.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleConstEnums.ts === - declare function use(a: any); >use : (a: any) => any >a : any diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js index 132d27a4ea0..4b1e28e9fda 100644 --- a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js +++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js @@ -1,5 +1,4 @@ //// [systemModuleConstEnumsSeparateCompilation.ts] - declare function use(a: any); const enum TopLevelConstEnum { X } diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols index d57740b75e9..3385728ef81 100644 --- a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols +++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts === - declare function use(a: any); >use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0)) ->a : Symbol(a, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 21)) +>a : Symbol(a, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 21)) const enum TopLevelConstEnum { X } ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 30)) export function foo() { ->foo : Symbol(foo, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 34)) +>foo : Symbol(foo, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 34)) use(TopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0)) ->TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30)) ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30)) +>TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 30)) use(M.NonTopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0)) ->M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44)) ->M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10)) ->M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 7, 1)) ->NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10)) ->X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44)) +>M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 44)) +>M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 8, 10)) +>M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 6, 1)) +>NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 8, 10)) +>X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 44)) } module M { ->M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 7, 1)) +>M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 6, 1)) export const enum NonTopLevelConstEnum { X } ->NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10)) ->X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44)) +>NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 8, 10)) +>X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 44)) } diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types index c3a352f66ec..23e34a0d40f 100644 --- a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types +++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts === - declare function use(a: any); >use : (a: any) => any >a : any diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.js b/tests/baselines/reference/systemModuleDeclarationMerging.js index d60a315b0a6..9a48570fb11 100644 --- a/tests/baselines/reference/systemModuleDeclarationMerging.js +++ b/tests/baselines/reference/systemModuleDeclarationMerging.js @@ -1,5 +1,4 @@ //// [systemModuleDeclarationMerging.ts] - export function F() {} export module F { var x; } diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.symbols b/tests/baselines/reference/systemModuleDeclarationMerging.symbols index 8efce4022ba..eef74655078 100644 --- a/tests/baselines/reference/systemModuleDeclarationMerging.symbols +++ b/tests/baselines/reference/systemModuleDeclarationMerging.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/systemModuleDeclarationMerging.ts === - export function F() {} ->F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 1, 22)) +>F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 0, 22)) export module F { var x; } ->F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 1, 22)) ->x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 2, 21)) +>F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 0, 22)) +>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 1, 21)) export class C {} ->C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 2, 26), Decl(systemModuleDeclarationMerging.ts, 4, 17)) +>C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 1, 26), Decl(systemModuleDeclarationMerging.ts, 3, 17)) export module C { var x; } ->C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 2, 26), Decl(systemModuleDeclarationMerging.ts, 4, 17)) ->x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 5, 21)) +>C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 1, 26), Decl(systemModuleDeclarationMerging.ts, 3, 17)) +>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 4, 21)) export enum E {} ->E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 5, 26), Decl(systemModuleDeclarationMerging.ts, 7, 16)) +>E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 4, 26), Decl(systemModuleDeclarationMerging.ts, 6, 16)) export module E { var x; } ->E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 5, 26), Decl(systemModuleDeclarationMerging.ts, 7, 16)) ->x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 8, 21)) +>E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 4, 26), Decl(systemModuleDeclarationMerging.ts, 6, 16)) +>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 7, 21)) diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.types b/tests/baselines/reference/systemModuleDeclarationMerging.types index 20bf1e67f51..9f0f03b23f1 100644 --- a/tests/baselines/reference/systemModuleDeclarationMerging.types +++ b/tests/baselines/reference/systemModuleDeclarationMerging.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleDeclarationMerging.ts === - export function F() {} >F : typeof F diff --git a/tests/baselines/reference/systemModuleExportDefault.js b/tests/baselines/reference/systemModuleExportDefault.js index 67341a04a0b..98fa71de5e2 100644 --- a/tests/baselines/reference/systemModuleExportDefault.js +++ b/tests/baselines/reference/systemModuleExportDefault.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModuleExportDefault.ts] //// //// [file1.ts] - export default function() {} //// [file2.ts] diff --git a/tests/baselines/reference/systemModuleExportDefault.symbols b/tests/baselines/reference/systemModuleExportDefault.symbols index d6e7cde9b71..af12bc2d6a8 100644 --- a/tests/baselines/reference/systemModuleExportDefault.symbols +++ b/tests/baselines/reference/systemModuleExportDefault.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/file1.ts === - -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === export default function foo() {} diff --git a/tests/baselines/reference/systemModuleExportDefault.types b/tests/baselines/reference/systemModuleExportDefault.types index 38b5abec8ed..a783a3d3c01 100644 --- a/tests/baselines/reference/systemModuleExportDefault.types +++ b/tests/baselines/reference/systemModuleExportDefault.types @@ -1,6 +1,5 @@ === tests/cases/compiler/file1.ts === - -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === export default function foo() {} diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js index df68f32b3bd..8337b4faea9 100644 --- a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js +++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js @@ -1,5 +1,4 @@ //// [systemModuleNonTopLevelModuleMembers.ts] - export class TopLevelClass {} export module TopLevelModule {var v;} export function TopLevelFunction(): void {} diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols index e0b69c71a2f..b6d721d5942 100644 --- a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols +++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts === - export class TopLevelClass {} >TopLevelClass : Symbol(TopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 0, 0)) export module TopLevelModule {var v;} ->TopLevelModule : Symbol(TopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 29)) ->v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 33)) +>TopLevelModule : Symbol(TopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 0, 29)) +>v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 33)) export function TopLevelFunction(): void {} ->TopLevelFunction : Symbol(TopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 37)) +>TopLevelFunction : Symbol(TopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 37)) export enum TopLevelEnum {E} ->TopLevelEnum : Symbol(TopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 43)) ->E : Symbol(TopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 4, 26)) +>TopLevelEnum : Symbol(TopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 43)) +>E : Symbol(TopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 26)) export module TopLevelModule2 { ->TopLevelModule2 : Symbol(TopLevelModule2, Decl(systemModuleNonTopLevelModuleMembers.ts, 4, 28)) +>TopLevelModule2 : Symbol(TopLevelModule2, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 28)) export class NonTopLevelClass {} ->NonTopLevelClass : Symbol(NonTopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 6, 31)) +>NonTopLevelClass : Symbol(NonTopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 5, 31)) export module NonTopLevelModule {var v;} ->NonTopLevelModule : Symbol(NonTopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 36)) ->v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 40)) +>NonTopLevelModule : Symbol(NonTopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 6, 36)) +>v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 40)) export function NonTopLevelFunction(): void {} ->NonTopLevelFunction : Symbol(NonTopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 44)) +>NonTopLevelFunction : Symbol(NonTopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 44)) export enum NonTopLevelEnum {E} ->NonTopLevelEnum : Symbol(NonTopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 9, 50)) ->E : Symbol(NonTopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 10, 33)) +>NonTopLevelEnum : Symbol(NonTopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 50)) +>E : Symbol(NonTopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 9, 33)) } diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types index ffe3d23f7a6..61edb6db4b0 100644 --- a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types +++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts === - export class TopLevelClass {} >TopLevelClass : TopLevelClass diff --git a/tests/baselines/reference/systemModuleWithSuperClass.js b/tests/baselines/reference/systemModuleWithSuperClass.js index 8ac8770d8b1..5964cb9c27f 100644 --- a/tests/baselines/reference/systemModuleWithSuperClass.js +++ b/tests/baselines/reference/systemModuleWithSuperClass.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModuleWithSuperClass.ts] //// //// [foo.ts] - export class Foo { a: string; } diff --git a/tests/baselines/reference/systemModuleWithSuperClass.symbols b/tests/baselines/reference/systemModuleWithSuperClass.symbols index 415e7d1e99f..0918d349ee5 100644 --- a/tests/baselines/reference/systemModuleWithSuperClass.symbols +++ b/tests/baselines/reference/systemModuleWithSuperClass.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/foo.ts === - export class Foo { >Foo : Symbol(Foo, Decl(foo.ts, 0, 0)) a: string; ->a : Symbol(Foo.a, Decl(foo.ts, 1, 18)) +>a : Symbol(Foo.a, Decl(foo.ts, 0, 18)) } === tests/cases/compiler/bar.ts === diff --git a/tests/baselines/reference/systemModuleWithSuperClass.types b/tests/baselines/reference/systemModuleWithSuperClass.types index 130f53f0ce3..b1e960984fc 100644 --- a/tests/baselines/reference/systemModuleWithSuperClass.types +++ b/tests/baselines/reference/systemModuleWithSuperClass.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.ts === - export class Foo { >Foo : Foo diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.js b/tests/baselines/reference/taggedTemplateContextualTyping1.js index 17618b50e8b..852ea29d2b1 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.js +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.js @@ -1,5 +1,4 @@ //// [taggedTemplateContextualTyping1.ts] - type FuncType = (x: (p: T) => T) => typeof x; function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, x: T): T; diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols index 3c50a6f92e4..320c0e74479 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols @@ -1,43 +1,42 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts === - type FuncType = (x: (p: T) => T) => typeof x; >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 1, 17)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 1, 21)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 1, 24)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 1, 21)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 1, 21)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 1, 17)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 0, 17)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 0, 21)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 0, 24)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 0, 21)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 0, 21)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 0, 17)) function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, x: T): T; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18)) +>templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 2, 21)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 2, 56)) +>FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 2, 69)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18)) + +function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 3, 21)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) >f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 3, 56)) >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 3, 69)) +>h : Symbol(h, Decl(taggedTemplateContextualTyping1.ts, 3, 69)) +>FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 3, 82)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) -function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) ->templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 4, 21)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 4, 56)) ->FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->h : Symbol(h, Decl(taggedTemplateContextualTyping1.ts, 4, 69)) ->FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 4, 82)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) - function tempTag1(...rest: any[]): T { ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 5, 18)) ->rest : Symbol(rest, Decl(taggedTemplateContextualTyping1.ts, 5, 21)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 5, 18)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) +>rest : Symbol(rest, Decl(taggedTemplateContextualTyping1.ts, 4, 21)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) return undefined; >undefined : Symbol(undefined) @@ -48,52 +47,52 @@ function tempTag1(...rest: any[]): T { // and it is an error to invoke an any-typed value with type arguments, // so this test will error. tempTag1 `${ x => { x(undefined); return x; } }${ 10 }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 12, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 12, 12)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 12, 12)) tempTag1 `${ x => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ 10 }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 13, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 13, 75)) >undefined : Symbol(undefined) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 13, 75)) tempTag1 `${ x => { x(undefined); return x; } }${ (y: (p: T) => T) => { y(undefined); return y } }${ undefined }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 15, 84)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 77)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 14, 81)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 14, 84)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 14, 81)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 14, 81)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 77)) >undefined : Symbol(undefined) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 77)) >undefined : Symbol(undefined) tempTag1 `${ (x: (p: T) => T) => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ undefined }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 16, 21)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 14)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 18)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 15, 21)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 18)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 18)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 14)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 14)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 75)) >undefined : Symbol(undefined) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 75)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.types b/tests/baselines/reference/taggedTemplateContextualTyping1.types index 4e207a0d6bb..26acf1d9ba6 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.types +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts === - type FuncType = (x: (p: T) => T) => typeof x; >FuncType : FuncType >x : (p: T) => T diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.js b/tests/baselines/reference/taggedTemplateContextualTyping2.js index 8adea53f470..eafeac6fab8 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.js +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.js @@ -1,5 +1,4 @@ //// [taggedTemplateContextualTyping2.ts] - type FuncType1 = (x: (p: T) => T) => typeof x; type FuncType2 = (x: (p: T) => T) => typeof x; diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols index a1ee63ef8b0..8c9459638d0 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols @@ -1,45 +1,44 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts === - type FuncType1 = (x: (p: T) => T) => typeof x; >FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 1, 25)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 0, 18)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 0, 22)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 0, 25)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 0, 22)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 0, 22)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 0, 18)) type FuncType2 = (x: (p: T) => T) => typeof x; ->FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 2, 18)) ->S : Symbol(S, Decl(taggedTemplateContextualTyping2.ts, 2, 22)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 2, 24)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 2, 28)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 2, 24)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 2, 24)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 2, 18)) +>FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) +>S : Symbol(S, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 24)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 1, 28)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 24)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 24)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 3, 18)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 3, 53)) +>FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 3, 67)) + +function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string; +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 4, 18)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) >f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 4, 53)) ->FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 4, 67)) - -function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 5, 18)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 5, 53)) ->FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49)) ->h : Symbol(h, Decl(taggedTemplateContextualTyping2.ts, 5, 67)) ->FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 5, 81)) +>FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49)) +>h : Symbol(h, Decl(taggedTemplateContextualTyping2.ts, 4, 67)) +>FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 4, 81)) function tempTag2(...rest: any[]): any { ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->rest : Symbol(rest, Decl(taggedTemplateContextualTyping2.ts, 6, 18)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>rest : Symbol(rest, Decl(taggedTemplateContextualTyping2.ts, 5, 18)) return undefined; >undefined : Symbol(undefined) @@ -50,27 +49,27 @@ function tempTag2(...rest: any[]): any { // and it is an error to invoke an any-typed value with type arguments, // so this test will error. tempTag2 `${ x => { x(undefined); return x; } }${ 0 }`; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 13, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 13, 12)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 13, 12)) tempTag2 `${ x => { x(undefined); return x; } }${ y => { y(null); return y; } }${ "hello" }`; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 14, 65)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 14, 65)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 14, 65)) tempTag2 `${ x => { x(undefined); return x; } }${ undefined }${ "hello" }`; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.types b/tests/baselines/reference/taggedTemplateContextualTyping2.types index 2dbf2c53c8b..60374853956 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.types +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts === - type FuncType1 = (x: (p: T) => T) => typeof x; >FuncType1 : FuncType1 >x : (p: T) => T diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js index 33c2914e3e8..10610fb28a9 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts] - - function f(...x: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols index 1d91e37ae01..c356f8d65bf 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols @@ -1,9 +1,7 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts === - - function f(...x: any[]) { >f : Symbol(f, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts, 2, 11)) +>x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts, 0, 11)) } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types index e40e80fe7f9..9b394f2bceb 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts === - - function f(...x: any[]) { >f : (...x: any[]) => void >x : any[] diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js index a3c6806b1d3..30b08ea23e2 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts] - function f(...x: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols index 85d72332960..558fe61ed82 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts === - function f(...x: any[]) { >f : Symbol(f, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts, 1, 11)) +>x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts, 0, 11)) } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types index 8a1c5f434a8..775914faeea 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts === - function f(...x: any[]) { >f : (...x: any[]) => void >x : any[] diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js index ca192ef98d3..159181febc1 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.ts] - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js] diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols index 3ee1a72f8e2..d5bcee8217f 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols @@ -1,5 +1,3 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.ts === - -No type information for this code. -No type information for this code.`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` +`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types index 6619696bb39..d4b77f95c4f 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.ts === - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` >`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` : string >" " : " " diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js index 46eb5e90cd9..1492af8fa52 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts] - function f(...x: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols index 1d969c1d300..43eabc71e86 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts === - function f(...x: any[]) { >f : Symbol(f, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts, 1, 11)) +>x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts, 0, 11)) } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types index 2fae6446989..dc6455c17a9 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts === - function f(...x: any[]) { >f : (...x: any[]) => void >x : any[] diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt index 2ead58862b6..4eae70010ce 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt @@ -1,13 +1,11 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(64,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(62,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '""' is not a valid type argument because it is not a supertype of candidate '0'. -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(77,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(75,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'. Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts (2 errors) ==== - - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js index 69dcd284183..e0427c28b87 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsTypeArgumentInference.ts] - - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt index 781456b8bbb..6a5897bedc7 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(63,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(62,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '""' is not a valid type argument because it is not a supertype of candidate '0'. -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(76,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(75,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'. Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts (2 errors) ==== - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js index 3097e40c9ad..379c7b87bcb 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsTypeArgumentInferenceES6.ts] - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js index fdac55da181..779585ac264 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithOverloadResolution2.ts] - function foo1(strs: TemplateStringsArray, x: number): string; function foo1(strs: string[], x: number): number; function foo1(...stuff: any[]): any { diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols index 241c43c4d78..fe66a0c1c19 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols @@ -1,56 +1,55 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts === - function foo1(strs: TemplateStringsArray, x: number): string; ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 14)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 14)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 41)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 41)) function foo1(strs: string[], x: number): number; ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 14)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 29)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 14)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 29)) function foo1(...stuff: any[]): any { ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) ->stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 3, 14)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) +>stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 14)) return undefined; >undefined : Symbol(undefined) } var a = foo1 `${1}`; ->a : Symbol(a, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 3)) ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) +>a : Symbol(a, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 6, 3)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) var b = foo1([], 1); ->b : Symbol(b, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 3)) ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) +>b : Symbol(b, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 3)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) function foo2(strs: string[], x: number): number; ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 14)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 29)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 14)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 29)) function foo2(strs: TemplateStringsArray, x: number): string; ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 14)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 14)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 41)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 41)) function foo2(...stuff: any[]): any { ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) ->stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 12, 14)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) +>stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 14)) return undefined; >undefined : Symbol(undefined) } var c = foo2 `${1}`; ->c : Symbol(c, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 16, 3)) ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) +>c : Symbol(c, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 15, 3)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) var d = foo2([], 1); ->d : Symbol(d, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 17, 3)) ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) +>d : Symbol(d, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 16, 3)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types index 38b2087ccbf..bd4c039f1f2 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts === - function foo1(strs: TemplateStringsArray, x: number): string; >foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; } >strs : TemplateStringsArray diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt index 2248fee5ceb..444985cb380 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(10,9): error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(19,4): error TS2339: Property 'foo' does not exist on type 'Date'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(45,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(63,9): error TS2345: Argument of type 'true' is not assignable to parameter of type 'number'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(64,18): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(70,18): error TS2339: Property 'toFixed' does not exist on type 'string'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(9,9): error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(18,4): error TS2339: Property 'foo' does not exist on type 'Date'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(44,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(62,9): error TS2345: Argument of type 'true' is not assignable to parameter of type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(63,18): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(69,18): error TS2339: Property 'toFixed' does not exist on type 'string'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts (6 errors) ==== - // Ambiguous call picks the first overload in declaration order function fn1(strs: TemplateStringsArray, s: string): string; function fn1(strs: TemplateStringsArray, n: number): number; diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js index 48c03b6d41d..df89f2aeea7 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithOverloadResolution3.ts] - // Ambiguous call picks the first overload in declaration order function fn1(strs: TemplateStringsArray, s: string): string; function fn1(strs: TemplateStringsArray, n: number): number; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js index 1c25578af2e..7a96d4b5e4d 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsWithTagNamedDeclare.ts] - - function declare(x: any, ...ys: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols index ae73d532a01..3e9d474f6fa 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols @@ -1,10 +1,8 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclare.ts === - - function declare(x: any, ...ys: any[]) { >declare : Symbol(declare, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 2, 17)) ->ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 2, 24)) +>x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 0, 17)) +>ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 0, 24)) } declare `Hello ${0} world!`; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types index b0accf616af..3d39c883056 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclare.ts === - - function declare(x: any, ...ys: any[]) { >declare : (x: any, ...ys: any[]) => void >x : any diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js index cd2833f3836..1984da087a4 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithTagNamedDeclareES6.ts] - function declare(x: any, ...ys: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols index 960a12d2357..e1408ce3834 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclareES6.ts === - function declare(x: any, ...ys: any[]) { >declare : Symbol(declare, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 1, 17)) ->ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 1, 24)) +>x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 0, 17)) +>ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 0, 24)) } declare `Hello ${0} world!`; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types index 6e474bf3474..57309b399ba 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclareES6.ts === - function declare(x: any, ...ys: any[]) { >declare : (x: any, ...ys: any[]) => void >x : any diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt index 6da8d2ffce3..ebd8383c024 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt @@ -1,9 +1,7 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(6,31): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(4,31): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts (1 errors) ==== - - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js index 334f61e453d..3e2889ce1f3 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts] - - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt index c1d18cd6f91..57f84840310 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(5,31): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(4,31): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts (1 errors) ==== - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js index 7691b83b3bc..9597723d2e5 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts] - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt index a64f5379e47..ce11c177e03 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts(6,15): error TS1160: Unterminated template literal. +tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts(5,15): error TS1160: Unterminated template literal. ==== tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js index 6e286da4cfd..9cd9f13ed67 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt index fab10f8a888..9386a2f9753 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts(6,4): error TS1160: Unterminated template literal. +tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts(5,4): error TS1160: Unterminated template literal. ==== tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js index 0de0d000c9c..6dda6482898 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt index 56a557e1a8c..f68bf5c23dc 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts(6,17): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts(5,17): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js index b469776180b..17a5582dd85 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions1.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt index 065cc2f4787..8f86e19ced9 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(6,18): error TS1109: Expression expected. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(6,21): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(5,18): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(5,21): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js index 5a3b933b866..1cadc11d9d5 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions2.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt index ca306a8ad8b..f9ec9ba0ca3 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(6,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(6,23): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(5,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(5,23): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js index 2a918b4edd1..2a85c0901d4 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions3.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt index 89995458485..cc499cb2578 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,24): error TS1109: Expression expected. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,28): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(5,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(5,24): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(5,28): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts (3 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js index 497ee53fc53..14bdfd4279e 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions4.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt index a264c6bc330..0a4f0724cc2 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(6,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(6,30): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(5,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(5,30): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js index eb95c8869fa..74f3591a7d4 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions5.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt index a5d3f132b69..15bcddb0033 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(6,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(6,23): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(5,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(5,23): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js index 5fb32e38905..9ed898a4188 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions6.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01.js b/tests/baselines/reference/templateStringControlCharacterEscapes01.js index 1b129e802e3..66c0836d82e 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes01.ts] - - var x = `\0\x00\u0000 0 00 0000`; //// [templateStringControlCharacterEscapes01.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols index b01d09de776..c533cf307c0 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01.ts === - - var x = `\0\x00\u0000 0 00 0000`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes01.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes01.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01.types b/tests/baselines/reference/templateStringControlCharacterEscapes01.types index 3d3b6801d5f..7bd2e89839c 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01.ts === - - var x = `\0\x00\u0000 0 00 0000`; >x : string >`\0\x00\u0000 0 00 0000` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js index 9015655576c..41e0618cdd3 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes01_ES6.ts] - var x = `\0\x00\u0000 0 00 0000`; //// [templateStringControlCharacterEscapes01_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols index af123cfa699..49582be8b0e 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01_ES6.ts === - var x = `\0\x00\u0000 0 00 0000`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes01_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes01_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types index 6744a6e7700..80962ecdd6a 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01_ES6.ts === - var x = `\0\x00\u0000 0 00 0000`; >x : string >`\0\x00\u0000 0 00 0000` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02.js b/tests/baselines/reference/templateStringControlCharacterEscapes02.js index 5b5d34dae02..d8d7a9008c5 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes02.ts] - - var x = `\x19\u0019 19`; //// [templateStringControlCharacterEscapes02.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols index e780fc6a41a..926faee625d 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02.ts === - - var x = `\x19\u0019 19`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes02.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes02.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02.types b/tests/baselines/reference/templateStringControlCharacterEscapes02.types index 9be908cc7b7..4656be748ec 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02.ts === - - var x = `\x19\u0019 19`; >x : string >`\x19\u0019 19` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js index 2d76674b4dd..aa998405cbf 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes02_ES6.ts] - var x = `\x19\u0019 19`; //// [templateStringControlCharacterEscapes02_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols index 9ee13522852..8bf84cb6855 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02_ES6.ts === - var x = `\x19\u0019 19`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes02_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes02_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types index 72116686d62..d50196f5913 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02_ES6.ts === - var x = `\x19\u0019 19`; >x : string >`\x19\u0019 19` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03.js b/tests/baselines/reference/templateStringControlCharacterEscapes03.js index a0e87fc7e0e..32eabd844ce 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes03.ts] - - var x = `\x1F\u001f 1F 1f`; //// [templateStringControlCharacterEscapes03.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols index d029ee806be..154b51509e8 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03.ts === - - var x = `\x1F\u001f 1F 1f`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes03.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes03.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03.types b/tests/baselines/reference/templateStringControlCharacterEscapes03.types index b2a944b2c21..b509b2ccd6c 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03.ts === - - var x = `\x1F\u001f 1F 1f`; >x : string >`\x1F\u001f 1F 1f` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js index b9b3df266d9..b13d7d53875 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes03_ES6.ts] - var x = `\x1F\u001f 1F 1f`; //// [templateStringControlCharacterEscapes03_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols index 16bb0fbc1e2..da84a1c5951 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03_ES6.ts === - var x = `\x1F\u001f 1F 1f`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes03_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes03_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types index ac296c10cdb..4d35fe85c41 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03_ES6.ts === - var x = `\x1F\u001f 1F 1f`; >x : string >`\x1F\u001f 1F 1f` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04.js b/tests/baselines/reference/templateStringControlCharacterEscapes04.js index 70636a584b4..19090f58dbd 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes04.ts] - - var x = `\x20\u0020 20`; //// [templateStringControlCharacterEscapes04.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols index 168c30a55f7..1dc8109d3fd 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04.ts === - - var x = `\x20\u0020 20`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes04.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes04.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04.types b/tests/baselines/reference/templateStringControlCharacterEscapes04.types index 07a674840fc..ca72e253d56 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04.ts === - - var x = `\x20\u0020 20`; >x : string >`\x20\u0020 20` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js index 17461fb0841..4e097420caf 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes04_ES6.ts] - var x = `\x20\u0020 20`; //// [templateStringControlCharacterEscapes04_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols index 040573ed76e..ac4a253f5fa 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04_ES6.ts === - var x = `\x20\u0020 20`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes04_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes04_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types index 5f1c1dab862..01b3f35ba9a 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04_ES6.ts === - var x = `\x20\u0020 20`; >x : string >`\x20\u0020 20` : string diff --git a/tests/baselines/reference/templateStringMultiline1.js b/tests/baselines/reference/templateStringMultiline1.js index e81cb89926a..dabb9ae93e3 100644 --- a/tests/baselines/reference/templateStringMultiline1.js +++ b/tests/baselines/reference/templateStringMultiline1.js @@ -1,6 +1,4 @@ //// [templateStringMultiline1.ts] - - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline1.symbols b/tests/baselines/reference/templateStringMultiline1.symbols index 3b169c1b1cb..ae52ffeb1fd 100644 --- a/tests/baselines/reference/templateStringMultiline1.symbols +++ b/tests/baselines/reference/templateStringMultiline1.symbols @@ -1,7 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1.ts === - -No type information for this code. -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline1.types b/tests/baselines/reference/templateStringMultiline1.types index 521d2a8382f..f66dd89a7bc 100644 --- a/tests/baselines/reference/templateStringMultiline1.types +++ b/tests/baselines/reference/templateStringMultiline1.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1.ts === - - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline1_ES6.js b/tests/baselines/reference/templateStringMultiline1_ES6.js index a44df4d0cc3..dfc6d59ecf7 100644 --- a/tests/baselines/reference/templateStringMultiline1_ES6.js +++ b/tests/baselines/reference/templateStringMultiline1_ES6.js @@ -1,5 +1,4 @@ //// [templateStringMultiline1_ES6.ts] - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline1_ES6.symbols b/tests/baselines/reference/templateStringMultiline1_ES6.symbols index 5e4716ac607..430db160490 100644 --- a/tests/baselines/reference/templateStringMultiline1_ES6.symbols +++ b/tests/baselines/reference/templateStringMultiline1_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1_ES6.ts === - -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline1_ES6.types b/tests/baselines/reference/templateStringMultiline1_ES6.types index 36e60c240f9..71e82a2e5c5 100644 --- a/tests/baselines/reference/templateStringMultiline1_ES6.types +++ b/tests/baselines/reference/templateStringMultiline1_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1_ES6.ts === - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline2.js b/tests/baselines/reference/templateStringMultiline2.js index a87e506f07d..df22de5fdee 100644 --- a/tests/baselines/reference/templateStringMultiline2.js +++ b/tests/baselines/reference/templateStringMultiline2.js @@ -1,6 +1,4 @@ //// [templateStringMultiline2.ts] - - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline2.symbols b/tests/baselines/reference/templateStringMultiline2.symbols index b4b341416c9..46007aa9115 100644 --- a/tests/baselines/reference/templateStringMultiline2.symbols +++ b/tests/baselines/reference/templateStringMultiline2.symbols @@ -1,7 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2.ts === - -No type information for this code. -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline2.types b/tests/baselines/reference/templateStringMultiline2.types index 97f7f1bd577..6184cb098b6 100644 --- a/tests/baselines/reference/templateStringMultiline2.types +++ b/tests/baselines/reference/templateStringMultiline2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2.ts === - - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline2_ES6.js b/tests/baselines/reference/templateStringMultiline2_ES6.js index 168c8bac39b..44b42651937 100644 --- a/tests/baselines/reference/templateStringMultiline2_ES6.js +++ b/tests/baselines/reference/templateStringMultiline2_ES6.js @@ -1,5 +1,4 @@ //// [templateStringMultiline2_ES6.ts] - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline2_ES6.symbols b/tests/baselines/reference/templateStringMultiline2_ES6.symbols index 288191d3d0f..ee01d641f9e 100644 --- a/tests/baselines/reference/templateStringMultiline2_ES6.symbols +++ b/tests/baselines/reference/templateStringMultiline2_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2_ES6.ts === - -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline2_ES6.types b/tests/baselines/reference/templateStringMultiline2_ES6.types index e05b245cfc7..3d123975330 100644 --- a/tests/baselines/reference/templateStringMultiline2_ES6.types +++ b/tests/baselines/reference/templateStringMultiline2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2_ES6.ts === - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline3.js b/tests/baselines/reference/templateStringMultiline3.js index bff65582515..31e59af26a8 100644 --- a/tests/baselines/reference/templateStringMultiline3.js +++ b/tests/baselines/reference/templateStringMultiline3.js @@ -1,6 +1,4 @@ //// [templateStringMultiline3.ts] - - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline3.symbols b/tests/baselines/reference/templateStringMultiline3.symbols index a0e1f6f8871..73f891399fe 100644 --- a/tests/baselines/reference/templateStringMultiline3.symbols +++ b/tests/baselines/reference/templateStringMultiline3.symbols @@ -1,7 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3.ts === - -No type information for this code. -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline3.types b/tests/baselines/reference/templateStringMultiline3.types index d059e2fc146..1d77fca9c56 100644 --- a/tests/baselines/reference/templateStringMultiline3.types +++ b/tests/baselines/reference/templateStringMultiline3.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3.ts === - - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline3_ES6.js b/tests/baselines/reference/templateStringMultiline3_ES6.js index aad544c13bb..374144c83a9 100644 --- a/tests/baselines/reference/templateStringMultiline3_ES6.js +++ b/tests/baselines/reference/templateStringMultiline3_ES6.js @@ -1,5 +1,4 @@ //// [templateStringMultiline3_ES6.ts] - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline3_ES6.symbols b/tests/baselines/reference/templateStringMultiline3_ES6.symbols index e4fa8a7edf4..8830da716ec 100644 --- a/tests/baselines/reference/templateStringMultiline3_ES6.symbols +++ b/tests/baselines/reference/templateStringMultiline3_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3_ES6.ts === - -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline3_ES6.types b/tests/baselines/reference/templateStringMultiline3_ES6.types index 5cb97d1b8b4..a1a696ebcfd 100644 --- a/tests/baselines/reference/templateStringMultiline3_ES6.types +++ b/tests/baselines/reference/templateStringMultiline3_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3_ES6.ts === - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js index 62629f3284f..44984d5ef9b 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js @@ -1,5 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes01.ts] - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` //// [templateStringPlainCharactersThatArePartsOfEscapes01.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols index 2b77345f8ff..71db8407b4b 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01.ts === - -No type information for this code.`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` +`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types index e64394e106f..acdf7898b71 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01.ts === - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` >`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` : string diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js index 4b599ee1d55..bf17386d9e7 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes01_ES6.ts] - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` //// [templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols index 33c8839e194..afe79fd9e2c 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.ts === - -No type information for this code.`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` +`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types index 0f49547ba70..110676b704b 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.ts === - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` >`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` : string diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js index 27090032ab9..cc7b26dec83 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js @@ -1,6 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes02.ts] - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` //// [templateStringPlainCharactersThatArePartsOfEscapes02.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols index f630d9e71e6..efc0e021f46 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols @@ -1,5 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02.ts === - -No type information for this code. -No type information for this code.`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` +`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types index 62d0190586a..7d78d7f29fb 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02.ts === - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` >`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` : string >" " : " " diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js index 0924c35b6ce..58fb198265f 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js @@ -1,5 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes02_ES6.ts] - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` //// [templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols index 934e0fc495c..927efffb2b5 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.ts === - -No type information for this code.`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` +`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types index cf07cae5b93..ee2b0b3600d 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.ts === - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` >`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` : string >" " : " " diff --git a/tests/baselines/reference/templateStringTermination1.js b/tests/baselines/reference/templateStringTermination1.js index 2243871f9ae..cbf85524478 100644 --- a/tests/baselines/reference/templateStringTermination1.js +++ b/tests/baselines/reference/templateStringTermination1.js @@ -1,5 +1,4 @@ //// [templateStringTermination1.ts] - `` //// [templateStringTermination1.js] diff --git a/tests/baselines/reference/templateStringTermination1.symbols b/tests/baselines/reference/templateStringTermination1.symbols index 5c3cf73af45..966d0939704 100644 --- a/tests/baselines/reference/templateStringTermination1.symbols +++ b/tests/baselines/reference/templateStringTermination1.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination1.ts === - -No type information for this code.`` +`` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination1.types b/tests/baselines/reference/templateStringTermination1.types index bdfa46ec46c..fa40007c96a 100644 --- a/tests/baselines/reference/templateStringTermination1.types +++ b/tests/baselines/reference/templateStringTermination1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination1.ts === - `` >`` : string diff --git a/tests/baselines/reference/templateStringTermination2.js b/tests/baselines/reference/templateStringTermination2.js index 37fd3ffd6f9..6e199e89a8a 100644 --- a/tests/baselines/reference/templateStringTermination2.js +++ b/tests/baselines/reference/templateStringTermination2.js @@ -1,5 +1,4 @@ //// [templateStringTermination2.ts] - `\\` //// [templateStringTermination2.js] diff --git a/tests/baselines/reference/templateStringTermination2.symbols b/tests/baselines/reference/templateStringTermination2.symbols index 927f257c21f..4593ef347f4 100644 --- a/tests/baselines/reference/templateStringTermination2.symbols +++ b/tests/baselines/reference/templateStringTermination2.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination2.ts === - -No type information for this code.`\\` +`\\` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination2.types b/tests/baselines/reference/templateStringTermination2.types index d5e6f9e15a9..205cb1e620a 100644 --- a/tests/baselines/reference/templateStringTermination2.types +++ b/tests/baselines/reference/templateStringTermination2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination2.ts === - `\\` >`\\` : string diff --git a/tests/baselines/reference/templateStringTermination3.js b/tests/baselines/reference/templateStringTermination3.js index 1bb2c2ab007..6ab2a4a9fe8 100644 --- a/tests/baselines/reference/templateStringTermination3.js +++ b/tests/baselines/reference/templateStringTermination3.js @@ -1,5 +1,4 @@ //// [templateStringTermination3.ts] - `\`` //// [templateStringTermination3.js] diff --git a/tests/baselines/reference/templateStringTermination3.symbols b/tests/baselines/reference/templateStringTermination3.symbols index a59aef6bfea..1e23b4e1eae 100644 --- a/tests/baselines/reference/templateStringTermination3.symbols +++ b/tests/baselines/reference/templateStringTermination3.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination3.ts === - -No type information for this code.`\`` +`\`` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination3.types b/tests/baselines/reference/templateStringTermination3.types index 0338dbf4c84..bdb09e00dc3 100644 --- a/tests/baselines/reference/templateStringTermination3.types +++ b/tests/baselines/reference/templateStringTermination3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination3.ts === - `\`` >`\`` : string diff --git a/tests/baselines/reference/templateStringTermination4.js b/tests/baselines/reference/templateStringTermination4.js index 29bbe4e9316..e9f4086c7a4 100644 --- a/tests/baselines/reference/templateStringTermination4.js +++ b/tests/baselines/reference/templateStringTermination4.js @@ -1,5 +1,4 @@ //// [templateStringTermination4.ts] - `\\\\` //// [templateStringTermination4.js] diff --git a/tests/baselines/reference/templateStringTermination4.symbols b/tests/baselines/reference/templateStringTermination4.symbols index ecf2ad9749f..294db6fec54 100644 --- a/tests/baselines/reference/templateStringTermination4.symbols +++ b/tests/baselines/reference/templateStringTermination4.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination4.ts === - -No type information for this code.`\\\\` +`\\\\` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination4.types b/tests/baselines/reference/templateStringTermination4.types index da45817ddd0..35a33014858 100644 --- a/tests/baselines/reference/templateStringTermination4.types +++ b/tests/baselines/reference/templateStringTermination4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination4.ts === - `\\\\` >`\\\\` : string diff --git a/tests/baselines/reference/templateStringTermination5.js b/tests/baselines/reference/templateStringTermination5.js index 769597f5209..f4bbd535d08 100644 --- a/tests/baselines/reference/templateStringTermination5.js +++ b/tests/baselines/reference/templateStringTermination5.js @@ -1,5 +1,4 @@ //// [templateStringTermination5.ts] - `\\\\\\` //// [templateStringTermination5.js] diff --git a/tests/baselines/reference/templateStringTermination5.symbols b/tests/baselines/reference/templateStringTermination5.symbols index 8ae94a18038..a1a51f1e438 100644 --- a/tests/baselines/reference/templateStringTermination5.symbols +++ b/tests/baselines/reference/templateStringTermination5.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination5.ts === - -No type information for this code.`\\\\\\` +`\\\\\\` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination5.types b/tests/baselines/reference/templateStringTermination5.types index 87641ff2298..34c6cf9fb82 100644 --- a/tests/baselines/reference/templateStringTermination5.types +++ b/tests/baselines/reference/templateStringTermination5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination5.ts === - `\\\\\\` >`\\\\\\` : string diff --git a/tests/baselines/reference/templateStringUnterminated1.errors.txt b/tests/baselines/reference/templateStringUnterminated1.errors.txt index 3353c062448..7bc3db7a09e 100644 --- a/tests/baselines/reference/templateStringUnterminated1.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated1.ts(2,2): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated1.ts(1,2): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated1.ts (1 errors) ==== - ` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated1.js b/tests/baselines/reference/templateStringUnterminated1.js index 0450f1f982c..19ec7a400f7 100644 --- a/tests/baselines/reference/templateStringUnterminated1.js +++ b/tests/baselines/reference/templateStringUnterminated1.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated1.ts] - ` //// [templateStringUnterminated1.js] diff --git a/tests/baselines/reference/templateStringUnterminated2.errors.txt b/tests/baselines/reference/templateStringUnterminated2.errors.txt index 0fd78e097b0..a8e873fcb08 100644 --- a/tests/baselines/reference/templateStringUnterminated2.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated2.ts(2,4): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated2.ts(1,4): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated2.ts (1 errors) ==== - `\` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated2.js b/tests/baselines/reference/templateStringUnterminated2.js index 2c6b113e9eb..16b7dc541db 100644 --- a/tests/baselines/reference/templateStringUnterminated2.js +++ b/tests/baselines/reference/templateStringUnterminated2.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated2.ts] - `\` //// [templateStringUnterminated2.js] diff --git a/tests/baselines/reference/templateStringUnterminated3.errors.txt b/tests/baselines/reference/templateStringUnterminated3.errors.txt index 1b25de284da..2a7a5c6bb9c 100644 --- a/tests/baselines/reference/templateStringUnterminated3.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated3.ts(2,4): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated3.ts(1,4): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated3.ts (1 errors) ==== - `\\ !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated3.js b/tests/baselines/reference/templateStringUnterminated3.js index 575b6122abf..bb0d7f4b740 100644 --- a/tests/baselines/reference/templateStringUnterminated3.js +++ b/tests/baselines/reference/templateStringUnterminated3.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated3.ts] - `\\ //// [templateStringUnterminated3.js] diff --git a/tests/baselines/reference/templateStringUnterminated4.errors.txt b/tests/baselines/reference/templateStringUnterminated4.errors.txt index 8eb41921187..ae972454659 100644 --- a/tests/baselines/reference/templateStringUnterminated4.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated4.ts(2,6): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated4.ts(1,6): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated4.ts (1 errors) ==== - `\\\` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated4.js b/tests/baselines/reference/templateStringUnterminated4.js index e94fe566a07..59059eaf8b9 100644 --- a/tests/baselines/reference/templateStringUnterminated4.js +++ b/tests/baselines/reference/templateStringUnterminated4.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated4.ts] - `\\\` //// [templateStringUnterminated4.js] diff --git a/tests/baselines/reference/templateStringUnterminated5.errors.txt b/tests/baselines/reference/templateStringUnterminated5.errors.txt index 20fd54e8112..c9e42252a92 100644 --- a/tests/baselines/reference/templateStringUnterminated5.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated5.ts(2,8): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated5.ts(1,8): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated5.ts (1 errors) ==== - `\\\\\` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated5.js b/tests/baselines/reference/templateStringUnterminated5.js index bee0b2dcd36..f4e3b58be23 100644 --- a/tests/baselines/reference/templateStringUnterminated5.js +++ b/tests/baselines/reference/templateStringUnterminated5.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated5.ts] - `\\\\\` //// [templateStringUnterminated5.js] diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1.js b/tests/baselines/reference/templateStringWhitespaceEscapes1.js index 1edd38c315b..5538af14778 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1.js @@ -1,6 +1,4 @@ //// [templateStringWhitespaceEscapes1.ts] - - `\t\n\v\f\r`; //// [templateStringWhitespaceEscapes1.js] diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols index 6c1598e0549..da8fe8ad0d6 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols @@ -1,5 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1.ts === - -No type information for this code. -No type information for this code.`\t\n\v\f\r`; +`\t\n\v\f\r`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1.types b/tests/baselines/reference/templateStringWhitespaceEscapes1.types index 1aa3d2b4924..e554f45685b 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1.ts === - - `\t\n\v\f\r`; >`\t\n\v\f\r` : string diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js index 55b93bd68a6..1996df5e193 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js @@ -1,5 +1,4 @@ //// [templateStringWhitespaceEscapes1_ES6.ts] - `\t\n\v\f\r`; //// [templateStringWhitespaceEscapes1_ES6.js] diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols index 53a6c6f9cf9..a7f9afeb126 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1_ES6.ts === - -No type information for this code.`\t\n\v\f\r`; +`\t\n\v\f\r`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types index 25e0134afbe..3888c1be068 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1_ES6.ts === - `\t\n\v\f\r`; >`\t\n\v\f\r` : string diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2.js b/tests/baselines/reference/templateStringWhitespaceEscapes2.js index 1a46cc7f750..4ac2c01d462 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2.js @@ -1,6 +1,4 @@ //// [templateStringWhitespaceEscapes2.ts] - - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols index 7c7de875379..6636b624222 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2.ts === - -No type information for this code. -No type information for this code.// , , , , , +// , , , , , No type information for this code.`\u0009\u000B\u000C\u0020\u00A0\uFEFF`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2.types b/tests/baselines/reference/templateStringWhitespaceEscapes2.types index 14f029cf999..3a43fe5e5a2 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2.ts === - - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; >`\u0009\u000B\u000C\u0020\u00A0\uFEFF` : string diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js index bf901c5e843..39709078ef7 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js @@ -1,5 +1,4 @@ //// [templateStringWhitespaceEscapes2_ES6.ts] - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols index 834ce22cc32..b8c4fb82a3e 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2_ES6.ts === - -No type information for this code.// , , , , , +// , , , , , No type information for this code.`\u0009\u000B\u000C\u0020\u00A0\uFEFF`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types index ff509c1913f..1627945e1c4 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2_ES6.ts === - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; >`\u0009\u000B\u000C\u0020\u00A0\uFEFF` : string diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01.js b/tests/baselines/reference/templateStringWithBackslashEscapes01.js index add1fdd9171..d304cc5a69b 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01.js +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01.js @@ -1,6 +1,4 @@ //// [templateStringWithBackslashEscapes01.ts] - - var a = `hello\world`; var b = `hello\\world`; var c = `hello\\\world`; diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols b/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols index 3c706afea5f..17411f75db7 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols @@ -1,15 +1,13 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01.ts === - - var a = `hello\world`; ->a : Symbol(a, Decl(templateStringWithBackslashEscapes01.ts, 2, 3)) +>a : Symbol(a, Decl(templateStringWithBackslashEscapes01.ts, 0, 3)) var b = `hello\\world`; ->b : Symbol(b, Decl(templateStringWithBackslashEscapes01.ts, 3, 3)) +>b : Symbol(b, Decl(templateStringWithBackslashEscapes01.ts, 1, 3)) var c = `hello\\\world`; ->c : Symbol(c, Decl(templateStringWithBackslashEscapes01.ts, 4, 3)) +>c : Symbol(c, Decl(templateStringWithBackslashEscapes01.ts, 2, 3)) var d = `hello\\\\world`; ->d : Symbol(d, Decl(templateStringWithBackslashEscapes01.ts, 5, 3)) +>d : Symbol(d, Decl(templateStringWithBackslashEscapes01.ts, 3, 3)) diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01.types b/tests/baselines/reference/templateStringWithBackslashEscapes01.types index 58f923dca54..e65c751b9d4 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01.types +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01.ts === - - var a = `hello\world`; >a : string >`hello\world` : string diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js index 3b5f1e2c14e..684ef0591aa 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [templateStringWithBackslashEscapes01_ES6.ts] - var a = `hello\world`; var b = `hello\\world`; var c = `hello\\\world`; diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols index c5ccef88d5a..32c7bd2e684 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01_ES6.ts === - var a = `hello\world`; ->a : Symbol(a, Decl(templateStringWithBackslashEscapes01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(templateStringWithBackslashEscapes01_ES6.ts, 0, 3)) var b = `hello\\world`; ->b : Symbol(b, Decl(templateStringWithBackslashEscapes01_ES6.ts, 2, 3)) +>b : Symbol(b, Decl(templateStringWithBackslashEscapes01_ES6.ts, 1, 3)) var c = `hello\\\world`; ->c : Symbol(c, Decl(templateStringWithBackslashEscapes01_ES6.ts, 3, 3)) +>c : Symbol(c, Decl(templateStringWithBackslashEscapes01_ES6.ts, 2, 3)) var d = `hello\\\\world`; ->d : Symbol(d, Decl(templateStringWithBackslashEscapes01_ES6.ts, 4, 3)) +>d : Symbol(d, Decl(templateStringWithBackslashEscapes01_ES6.ts, 3, 3)) diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types index 7d158dd14f4..9d1622609be 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01_ES6.ts === - var a = `hello\world`; >a : string >`hello\world` : string diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt index 94ab5028647..2c11f638a8a 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(7,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts (1 errors) ==== - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js index 1ebc479593d..7c8beb428c8 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js @@ -1,5 +1,4 @@ //// [templateStringsArrayTypeDefinedInES5Mode.ts] - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt index 1201c82f4d0..26063c45a0f 100644 --- a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/templateStringsArrayTypeNotDefinedES5Mode.ts(5,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/compiler/templateStringsArrayTypeNotDefinedES5Mode.ts(4,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeNotDefinedES5Mode.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: number, z: number) { } diff --git a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js index 69d61d79554..6daa46d037b 100644 --- a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js +++ b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js @@ -1,5 +1,4 @@ //// [templateStringsArrayTypeNotDefinedES5Mode.ts] - function f(x: TemplateStringsArray, y: number, z: number) { } diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt index f410d408482..c1bb393c213 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(7,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts (1 errors) ==== - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js index 95ab43743ae..4fc3b2fcf33 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js @@ -1,5 +1,4 @@ //// [templateStringsArrayTypeRedefinedInES6Mode.ts] - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt index 6b11fdb661a..402b3284699 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt @@ -1,9 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(3,27): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(1,27): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts (1 errors) ==== - - `${function (x: number) { x = "bad"; } }`; ~ !!! error TS2322: Type '"bad"' is not assignable to type 'number'. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js index 72d0fd8c8db..f01741ce68d 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js @@ -1,6 +1,4 @@ //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts] - - `${function (x: number) { x = "bad"; } }`; //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js] diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt index 8d5a8bb4885..f225154aab5 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(2,27): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(1,27): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts (1 errors) ==== - `${function (x: number) { x = "bad"; } }`; ~ !!! error TS2322: Type '"bad"' is not assignable to type 'number'. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js index 18fae66c78a..a549dc94e3d 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js @@ -1,5 +1,4 @@ //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts] - `${function (x: number) { x = "bad"; } }`; //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js] diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.js b/tests/baselines/reference/ternaryExpressionSourceMap.js index 4b43726b281..4fa12f10bd4 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.js +++ b/tests/baselines/reference/ternaryExpressionSourceMap.js @@ -1,5 +1,4 @@ //// [ternaryExpressionSourceMap.ts] - var x = 1; var foo = x ? () => 0 : () => 0; diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.js.map b/tests/baselines/reference/ternaryExpressionSourceMap.js.map index f7ddfe9024c..9340c972274 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.js.map +++ b/tests/baselines/reference/ternaryExpressionSourceMap.js.map @@ -1,2 +1,2 @@ //// [ternaryExpressionSourceMap.js.map] -{"version":3,"file":"ternaryExpressionSourceMap.js","sourceRoot":"","sources":["ternaryExpressionSourceMap.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,IAAI,GAAG,GAAG,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"ternaryExpressionSourceMap.js","sourceRoot":"","sources":["ternaryExpressionSourceMap.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,IAAI,GAAG,GAAG,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt b/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt index 51807286b63..d46e703e357 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt +++ b/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt @@ -16,19 +16,18 @@ sourceFile:ternaryExpressionSourceMap.ts 5 > ^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > x 4 > = 5 > 1 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>var foo = x ? function () { return 0; } : function () { return 0; }; 1-> @@ -68,23 +67,23 @@ sourceFile:ternaryExpressionSourceMap.ts 16> 17> 0 18> ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -4 >Emitted(2, 11) Source(3, 11) + SourceIndex(0) -5 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -6 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -7 >Emitted(2, 29) Source(3, 21) + SourceIndex(0) -8 >Emitted(2, 36) Source(3, 21) + SourceIndex(0) -9 >Emitted(2, 37) Source(3, 22) + SourceIndex(0) -10>Emitted(2, 39) Source(3, 21) + SourceIndex(0) -11>Emitted(2, 40) Source(3, 22) + SourceIndex(0) -12>Emitted(2, 43) Source(3, 25) + SourceIndex(0) -13>Emitted(2, 57) Source(3, 31) + SourceIndex(0) -14>Emitted(2, 64) Source(3, 31) + SourceIndex(0) -15>Emitted(2, 65) Source(3, 32) + SourceIndex(0) -16>Emitted(2, 67) Source(3, 31) + SourceIndex(0) -17>Emitted(2, 68) Source(3, 32) + SourceIndex(0) -18>Emitted(2, 69) Source(3, 33) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +4 >Emitted(2, 11) Source(2, 11) + SourceIndex(0) +5 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +6 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +7 >Emitted(2, 29) Source(2, 21) + SourceIndex(0) +8 >Emitted(2, 36) Source(2, 21) + SourceIndex(0) +9 >Emitted(2, 37) Source(2, 22) + SourceIndex(0) +10>Emitted(2, 39) Source(2, 21) + SourceIndex(0) +11>Emitted(2, 40) Source(2, 22) + SourceIndex(0) +12>Emitted(2, 43) Source(2, 25) + SourceIndex(0) +13>Emitted(2, 57) Source(2, 31) + SourceIndex(0) +14>Emitted(2, 64) Source(2, 31) + SourceIndex(0) +15>Emitted(2, 65) Source(2, 32) + SourceIndex(0) +16>Emitted(2, 67) Source(2, 31) + SourceIndex(0) +17>Emitted(2, 68) Source(2, 32) + SourceIndex(0) +18>Emitted(2, 69) Source(2, 33) + SourceIndex(0) --- >>>//# sourceMappingURL=ternaryExpressionSourceMap.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.symbols b/tests/baselines/reference/ternaryExpressionSourceMap.symbols index 5893e5cb2c5..39510b0b57c 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.symbols +++ b/tests/baselines/reference/ternaryExpressionSourceMap.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/ternaryExpressionSourceMap.ts === - var x = 1; ->x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 1, 3)) +>x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 0, 3)) var foo = x ? () => 0 : () => 0; ->foo : Symbol(foo, Decl(ternaryExpressionSourceMap.ts, 2, 3)) ->x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 1, 3)) +>foo : Symbol(foo, Decl(ternaryExpressionSourceMap.ts, 1, 3)) +>x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 0, 3)) diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.types b/tests/baselines/reference/ternaryExpressionSourceMap.types index d6d17091b43..ccc36358491 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.types +++ b/tests/baselines/reference/ternaryExpressionSourceMap.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ternaryExpressionSourceMap.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js index 51cc5a24bb6..f492460cff0 100644 --- a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js +++ b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js @@ -1,5 +1,4 @@ //// [thisTypeInBasePropertyAndDerivedContainerOfBase01.ts] - interface BoxOfFoo { item: T } diff --git a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols index 566bf3aa093..a7f98468e2e 100644 --- a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols +++ b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols @@ -1,27 +1,26 @@ === tests/cases/conformance/types/thisType/thisTypeInBasePropertyAndDerivedContainerOfBase01.ts === - interface BoxOfFoo { >BoxOfFoo : Symbol(BoxOfFoo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 0)) ->T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 1, 19)) ->Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 3, 1)) +>T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 19)) +>Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 2, 1)) item: T ->item : Symbol(BoxOfFoo.item, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 1, 35)) ->T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 1, 19)) +>item : Symbol(BoxOfFoo.item, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 35)) +>T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 19)) } interface Foo { ->Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 3, 1)) +>Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 2, 1)) self: this; ->self : Symbol(Foo.self, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 5, 15)) +>self : Symbol(Foo.self, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 4, 15)) } interface Bar extends Foo { ->Bar : Symbol(Bar, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 7, 1)) ->Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 3, 1)) +>Bar : Symbol(Bar, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 6, 1)) +>Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 2, 1)) other: BoxOfFoo; ->other : Symbol(Bar.other, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 9, 27)) +>other : Symbol(Bar.other, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 8, 27)) >BoxOfFoo : Symbol(BoxOfFoo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 0)) } diff --git a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types index 9f6b83df057..d5142a1dfe3 100644 --- a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types +++ b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/thisType/thisTypeInBasePropertyAndDerivedContainerOfBase01.ts === - interface BoxOfFoo { >BoxOfFoo : BoxOfFoo >T : T diff --git a/tests/baselines/reference/throwInEnclosingStatements.js b/tests/baselines/reference/throwInEnclosingStatements.js index 83928d71bff..eb4da2e6c4d 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.js +++ b/tests/baselines/reference/throwInEnclosingStatements.js @@ -1,5 +1,4 @@ //// [throwInEnclosingStatements.ts] - function fn(x) { throw x; } diff --git a/tests/baselines/reference/throwInEnclosingStatements.symbols b/tests/baselines/reference/throwInEnclosingStatements.symbols index 63ed9dde578..3071c8efd37 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.symbols +++ b/tests/baselines/reference/throwInEnclosingStatements.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts === - function fn(x) { >fn : Symbol(fn, Decl(throwInEnclosingStatements.ts, 0, 0)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12)) throw x; ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12)) } (x: T) => { throw x; } ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4)) var y: string; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) switch (y) { ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) case 'a': throw y; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) default: throw y; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) } var z = 0; ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) while (z < 10) { ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) throw z; ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) } for (var i = 0; ;) { throw i; } ->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8)) ->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8)) +>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8)) +>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8)) for (var idx in {}) { throw idx; } ->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8)) ->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8)) +>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8)) +>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8)) do { throw null; }while(true) var j = 0; ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) while (j < 0) { throw j; } ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) class C { ->C : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8)) +>C : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8)) private value: T; ->value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 29, 12)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8)) +>value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 28, 12)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8)) biz() { ->biz : Symbol(C.biz, Decl(throwInEnclosingStatements.ts, 30, 21)) +>biz : Symbol(C.biz, Decl(throwInEnclosingStatements.ts, 29, 21)) throw this.value; ->this.value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 29, 12)) ->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) ->value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 29, 12)) +>this.value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 28, 12)) +>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) +>value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 28, 12)) } constructor() { throw this; ->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) +>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) } } var aa = { ->aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 40, 3)) +>aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 39, 3)) id:12, ->id : Symbol(id, Decl(throwInEnclosingStatements.ts, 40, 10)) +>id : Symbol(id, Decl(throwInEnclosingStatements.ts, 39, 10)) biz() { ->biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 41, 10)) +>biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 40, 10)) throw this; } diff --git a/tests/baselines/reference/throwInEnclosingStatements.types b/tests/baselines/reference/throwInEnclosingStatements.types index 2d99ac435ae..e031d00147d 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.types +++ b/tests/baselines/reference/throwInEnclosingStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts === - function fn(x) { >fn : (x: any) => void >x : any diff --git a/tests/baselines/reference/throwStatements.js b/tests/baselines/reference/throwStatements.js index eb25d0a895b..0773ecba845 100644 --- a/tests/baselines/reference/throwStatements.js +++ b/tests/baselines/reference/throwStatements.js @@ -1,5 +1,4 @@ //// [throwStatements.ts] - // all legal interface I { diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols index 854fbcbe90b..e4d09aeb0e8 100644 --- a/tests/baselines/reference/throwStatements.symbols +++ b/tests/baselines/reference/throwStatements.symbols @@ -1,185 +1,184 @@ === tests/cases/conformance/statements/throwStatements/throwStatements.ts === - // all legal interface I { >I : Symbol(I, Decl(throwStatements.ts, 0, 0)) id: number; ->id : Symbol(I.id, Decl(throwStatements.ts, 3, 13)) +>id : Symbol(I.id, Decl(throwStatements.ts, 2, 13)) } class C implements I { ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) >I : Symbol(I, Decl(throwStatements.ts, 0, 0)) id: number; ->id : Symbol(C.id, Decl(throwStatements.ts, 7, 22)) +>id : Symbol(C.id, Decl(throwStatements.ts, 6, 22)) } class D{ ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) source: T; ->source : Symbol(D.source, Decl(throwStatements.ts, 11, 11)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>source : Symbol(D.source, Decl(throwStatements.ts, 10, 11)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) recurse: D; ->recurse : Symbol(D.recurse, Decl(throwStatements.ts, 12, 14)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>recurse : Symbol(D.recurse, Decl(throwStatements.ts, 11, 14)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) wrapped: D> ->wrapped : Symbol(D.wrapped, Decl(throwStatements.ts, 13, 18)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>wrapped : Symbol(D.wrapped, Decl(throwStatements.ts, 12, 18)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(throwStatements.ts, 15, 1)) ->x : Symbol(x, Decl(throwStatements.ts, 17, 11)) +>F : Symbol(F, Decl(throwStatements.ts, 14, 1)) +>x : Symbol(x, Decl(throwStatements.ts, 16, 11)) module M { ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) export class A { ->A : Symbol(A, Decl(throwStatements.ts, 19, 10)) +>A : Symbol(A, Decl(throwStatements.ts, 18, 10)) name: string; ->name : Symbol(A.name, Decl(throwStatements.ts, 20, 20)) +>name : Symbol(A.name, Decl(throwStatements.ts, 19, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(throwStatements.ts, 22, 5)) ->x : Symbol(x, Decl(throwStatements.ts, 24, 23)) +>F2 : Symbol(F2, Decl(throwStatements.ts, 21, 5)) +>x : Symbol(x, Decl(throwStatements.ts, 23, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(throwStatements.ts, 24, 23)) +>x : Symbol(x, Decl(throwStatements.ts, 23, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var aNumber = 9.9; ->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3)) +>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3)) throw aNumber; ->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3)) +>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3)) var aString = 'this is a string'; ->aString : Symbol(aString, Decl(throwStatements.ts, 29, 3)) +>aString : Symbol(aString, Decl(throwStatements.ts, 28, 3)) throw aString; ->aString : Symbol(aString, Decl(throwStatements.ts, 29, 3)) +>aString : Symbol(aString, Decl(throwStatements.ts, 28, 3)) var aDate = new Date(12); ->aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3)) +>aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw aDate; ->aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3)) +>aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) var anObject = new Object(); ->anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3)) +>anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw anObject; ->anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3)) +>anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) var anAny = null; ->anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3)) +>anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3)) throw anAny; ->anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3)) +>anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3)) var anOtherAny = new C(); ->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3)) ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw anOtherAny; ->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3)) +>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3)) var anUndefined = undefined; ->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3)) +>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3)) >undefined : Symbol(undefined) throw anUndefined; ->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3)) +>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3)) var aClass = new C(); ->aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3)) ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw aClass; ->aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3)) +>aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3)) var aGenericClass = new D(); ->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) throw aGenericClass; ->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3)) +>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3)) var anObjectLiteral = { id: 12 }; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3)) ->id : Symbol(id, Decl(throwStatements.ts, 47, 23)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3)) +>id : Symbol(id, Decl(throwStatements.ts, 46, 23)) throw anObjectLiteral; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3)) var aFunction = F; ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) ->F : Symbol(F, Decl(throwStatements.ts, 15, 1)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) +>F : Symbol(F, Decl(throwStatements.ts, 14, 1)) throw aFunction; ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) throw aFunction(''); ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) var aLambda = (x) => 2; ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) ->x : Symbol(x, Decl(throwStatements.ts, 53, 15)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 52, 15)) throw aLambda; ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) throw aLambda(1); ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) var aModule = M; ->aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3)) ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) throw aModule; ->aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3)) +>aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3)) throw typeof M; ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) var aClassInModule = new M.A(); ->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3)) ->M.A : Symbol(M.A, Decl(throwStatements.ts, 19, 10)) ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) ->A : Symbol(M.A, Decl(throwStatements.ts, 19, 10)) +>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3)) +>M.A : Symbol(M.A, Decl(throwStatements.ts, 18, 10)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>A : Symbol(M.A, Decl(throwStatements.ts, 18, 10)) throw aClassInModule; ->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3)) +>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3)) var aFunctionInModule = M.F2; ->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3)) ->M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5)) ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) ->F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3)) +>M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5)) throw aFunctionInModule; ->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3)) // no initializer or annotation, so this is an 'any' var x; ->x : Symbol(x, Decl(throwStatements.ts, 66, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 65, 3)) throw x; ->x : Symbol(x, Decl(throwStatements.ts, 66, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 65, 3)) // literals throw 0.0; @@ -191,13 +190,13 @@ throw undefined; throw 'a string'; throw function () { return 'a string' }; throw (x:T) => 42; ->T : Symbol(T, Decl(throwStatements.ts, 76, 7)) ->x : Symbol(x, Decl(throwStatements.ts, 76, 10)) ->T : Symbol(T, Decl(throwStatements.ts, 76, 7)) +>T : Symbol(T, Decl(throwStatements.ts, 75, 7)) +>x : Symbol(x, Decl(throwStatements.ts, 75, 10)) +>T : Symbol(T, Decl(throwStatements.ts, 75, 7)) throw { x: 12, y: 13 }; ->x : Symbol(x, Decl(throwStatements.ts, 77, 7)) ->y : Symbol(y, Decl(throwStatements.ts, 77, 14)) +>x : Symbol(x, Decl(throwStatements.ts, 76, 7)) +>y : Symbol(y, Decl(throwStatements.ts, 76, 14)) throw []; throw ['a', ['b']]; @@ -206,11 +205,11 @@ throw new Date(); >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new C(); ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw new Object(); >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new D(); ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types index 3c8fd64ee39..9ad2d954f27 100644 --- a/tests/baselines/reference/throwStatements.types +++ b/tests/baselines/reference/throwStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/throwStatements/throwStatements.ts === - // all legal interface I { diff --git a/tests/baselines/reference/trailingCommasES3.js b/tests/baselines/reference/trailingCommasES3.js index 554390a83ea..dba0ec31ad7 100644 --- a/tests/baselines/reference/trailingCommasES3.js +++ b/tests/baselines/reference/trailingCommasES3.js @@ -1,5 +1,4 @@ //// [trailingCommasES3.ts] - var o1 = { a: 1, b: 2 }; var o2 = { a: 1, b: 2, }; var o3 = { a: 1, }; diff --git a/tests/baselines/reference/trailingCommasES3.symbols b/tests/baselines/reference/trailingCommasES3.symbols index f176c9765c9..aae02469709 100644 --- a/tests/baselines/reference/trailingCommasES3.symbols +++ b/tests/baselines/reference/trailingCommasES3.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/trailingCommasES3.ts === - var o1 = { a: 1, b: 2 }; ->o1 : Symbol(o1, Decl(trailingCommasES3.ts, 1, 3)) +>o1 : Symbol(o1, Decl(trailingCommasES3.ts, 0, 3)) +>a : Symbol(a, Decl(trailingCommasES3.ts, 0, 10)) +>b : Symbol(b, Decl(trailingCommasES3.ts, 0, 16)) + +var o2 = { a: 1, b: 2, }; +>o2 : Symbol(o2, Decl(trailingCommasES3.ts, 1, 3)) >a : Symbol(a, Decl(trailingCommasES3.ts, 1, 10)) >b : Symbol(b, Decl(trailingCommasES3.ts, 1, 16)) -var o2 = { a: 1, b: 2, }; ->o2 : Symbol(o2, Decl(trailingCommasES3.ts, 2, 3)) ->a : Symbol(a, Decl(trailingCommasES3.ts, 2, 10)) ->b : Symbol(b, Decl(trailingCommasES3.ts, 2, 16)) - var o3 = { a: 1, }; ->o3 : Symbol(o3, Decl(trailingCommasES3.ts, 3, 3)) ->a : Symbol(a, Decl(trailingCommasES3.ts, 3, 10)) +>o3 : Symbol(o3, Decl(trailingCommasES3.ts, 2, 3)) +>a : Symbol(a, Decl(trailingCommasES3.ts, 2, 10)) var o4 = {}; ->o4 : Symbol(o4, Decl(trailingCommasES3.ts, 4, 3)) +>o4 : Symbol(o4, Decl(trailingCommasES3.ts, 3, 3)) var a1 = [1, 2]; ->a1 : Symbol(a1, Decl(trailingCommasES3.ts, 6, 3)) +>a1 : Symbol(a1, Decl(trailingCommasES3.ts, 5, 3)) var a2 = [1, 2, ]; ->a2 : Symbol(a2, Decl(trailingCommasES3.ts, 7, 3)) +>a2 : Symbol(a2, Decl(trailingCommasES3.ts, 6, 3)) var a3 = [1, ]; ->a3 : Symbol(a3, Decl(trailingCommasES3.ts, 8, 3)) +>a3 : Symbol(a3, Decl(trailingCommasES3.ts, 7, 3)) var a4 = []; ->a4 : Symbol(a4, Decl(trailingCommasES3.ts, 9, 3)) +>a4 : Symbol(a4, Decl(trailingCommasES3.ts, 8, 3)) var a5 = [1, , ]; ->a5 : Symbol(a5, Decl(trailingCommasES3.ts, 10, 3)) +>a5 : Symbol(a5, Decl(trailingCommasES3.ts, 9, 3)) var a6 = [, , ]; ->a6 : Symbol(a6, Decl(trailingCommasES3.ts, 11, 3)) +>a6 : Symbol(a6, Decl(trailingCommasES3.ts, 10, 3)) diff --git a/tests/baselines/reference/trailingCommasES3.types b/tests/baselines/reference/trailingCommasES3.types index 21e397a1c46..c2f689b3152 100644 --- a/tests/baselines/reference/trailingCommasES3.types +++ b/tests/baselines/reference/trailingCommasES3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/trailingCommasES3.ts === - var o1 = { a: 1, b: 2 }; >o1 : { a: number; b: number; } >{ a: 1, b: 2 } : { a: number; b: number; } diff --git a/tests/baselines/reference/trailingCommasES5.js b/tests/baselines/reference/trailingCommasES5.js index e54e911189a..29b32206c76 100644 --- a/tests/baselines/reference/trailingCommasES5.js +++ b/tests/baselines/reference/trailingCommasES5.js @@ -1,5 +1,4 @@ //// [trailingCommasES5.ts] - var o1 = { a: 1, b: 2 }; var o2 = { a: 1, b: 2, }; var o3 = { a: 1, }; diff --git a/tests/baselines/reference/trailingCommasES5.symbols b/tests/baselines/reference/trailingCommasES5.symbols index 1cf7a321547..d65b6d81b13 100644 --- a/tests/baselines/reference/trailingCommasES5.symbols +++ b/tests/baselines/reference/trailingCommasES5.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/trailingCommasES5.ts === - var o1 = { a: 1, b: 2 }; ->o1 : Symbol(o1, Decl(trailingCommasES5.ts, 1, 3)) +>o1 : Symbol(o1, Decl(trailingCommasES5.ts, 0, 3)) +>a : Symbol(a, Decl(trailingCommasES5.ts, 0, 10)) +>b : Symbol(b, Decl(trailingCommasES5.ts, 0, 16)) + +var o2 = { a: 1, b: 2, }; +>o2 : Symbol(o2, Decl(trailingCommasES5.ts, 1, 3)) >a : Symbol(a, Decl(trailingCommasES5.ts, 1, 10)) >b : Symbol(b, Decl(trailingCommasES5.ts, 1, 16)) -var o2 = { a: 1, b: 2, }; ->o2 : Symbol(o2, Decl(trailingCommasES5.ts, 2, 3)) ->a : Symbol(a, Decl(trailingCommasES5.ts, 2, 10)) ->b : Symbol(b, Decl(trailingCommasES5.ts, 2, 16)) - var o3 = { a: 1, }; ->o3 : Symbol(o3, Decl(trailingCommasES5.ts, 3, 3)) ->a : Symbol(a, Decl(trailingCommasES5.ts, 3, 10)) +>o3 : Symbol(o3, Decl(trailingCommasES5.ts, 2, 3)) +>a : Symbol(a, Decl(trailingCommasES5.ts, 2, 10)) var o4 = {}; ->o4 : Symbol(o4, Decl(trailingCommasES5.ts, 4, 3)) +>o4 : Symbol(o4, Decl(trailingCommasES5.ts, 3, 3)) var a1 = [1, 2]; ->a1 : Symbol(a1, Decl(trailingCommasES5.ts, 6, 3)) +>a1 : Symbol(a1, Decl(trailingCommasES5.ts, 5, 3)) var a2 = [1, 2, ]; ->a2 : Symbol(a2, Decl(trailingCommasES5.ts, 7, 3)) +>a2 : Symbol(a2, Decl(trailingCommasES5.ts, 6, 3)) var a3 = [1, ]; ->a3 : Symbol(a3, Decl(trailingCommasES5.ts, 8, 3)) +>a3 : Symbol(a3, Decl(trailingCommasES5.ts, 7, 3)) var a4 = []; ->a4 : Symbol(a4, Decl(trailingCommasES5.ts, 9, 3)) +>a4 : Symbol(a4, Decl(trailingCommasES5.ts, 8, 3)) var a5 = [1, , ]; ->a5 : Symbol(a5, Decl(trailingCommasES5.ts, 10, 3)) +>a5 : Symbol(a5, Decl(trailingCommasES5.ts, 9, 3)) var a6 = [, , ]; ->a6 : Symbol(a6, Decl(trailingCommasES5.ts, 11, 3)) +>a6 : Symbol(a6, Decl(trailingCommasES5.ts, 10, 3)) diff --git a/tests/baselines/reference/trailingCommasES5.types b/tests/baselines/reference/trailingCommasES5.types index 22d4fb37780..3b5f9638a5b 100644 --- a/tests/baselines/reference/trailingCommasES5.types +++ b/tests/baselines/reference/trailingCommasES5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/trailingCommasES5.ts === - var o1 = { a: 1, b: 2 }; >o1 : { a: number; b: number; } >{ a: 1, b: 2 } : { a: number; b: number; } diff --git a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js index 495e9354024..64df1ec5a75 100644 --- a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js +++ b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js @@ -1,5 +1,4 @@ //// [trailingCommasInFunctionParametersAndArguments.ts] - function f1(x,) {} f1(1,); diff --git a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols index 2ee58a747b7..2d7a1f07e5a 100644 --- a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols +++ b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols @@ -1,57 +1,56 @@ === tests/cases/conformance/es7/trailingCommasInFunctionParametersAndArguments.ts === - function f1(x,) {} >f1 : Symbol(f1, Decl(trailingCommasInFunctionParametersAndArguments.ts, 0, 0)) ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 1, 12)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 0, 12)) f1(1,); >f1 : Symbol(f1, Decl(trailingCommasInFunctionParametersAndArguments.ts, 0, 0)) function f2(...args,) {} ->f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 3, 7)) ->args : Symbol(args, Decl(trailingCommasInFunctionParametersAndArguments.ts, 5, 12)) +>f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 2, 7)) +>args : Symbol(args, Decl(trailingCommasInFunctionParametersAndArguments.ts, 4, 12)) f2(...[],); ->f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 3, 7)) +>f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 2, 7)) // Not confused by overloads declare function f3(x, ): number; ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 20)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 20)) declare function f3(x, y,): string; ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 11, 20)) ->y : Symbol(y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 11, 22)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 20)) +>y : Symbol(y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 22)) f3(1,); ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) f3(1, 2,); ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) // Works for constructors too class X { ->X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 14, 18)) +>X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 13, 18)) constructor(a,) { } ->a : Symbol(a, Decl(trailingCommasInFunctionParametersAndArguments.ts, 18, 16)) +>a : Symbol(a, Decl(trailingCommasInFunctionParametersAndArguments.ts, 17, 16)) // See trailingCommasInGetter.ts set x(value,) { } ->x : Symbol(X.x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 18, 23)) ->value : Symbol(value, Decl(trailingCommasInFunctionParametersAndArguments.ts, 20, 10)) +>x : Symbol(X.x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 17, 23)) +>value : Symbol(value, Decl(trailingCommasInFunctionParametersAndArguments.ts, 19, 10)) } interface Y { ->Y : Symbol(Y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 21, 1)) +>Y : Symbol(Y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 20, 1)) new(x,); ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 23, 8)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 22, 8)) (x,); ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 24, 5)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 23, 5)) } new X(1,); ->X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 14, 18)) +>X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 13, 18)) diff --git a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types index 00cca0b5e87..9df4b0afb50 100644 --- a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types +++ b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/trailingCommasInFunctionParametersAndArguments.ts === - function f1(x,) {} >f1 : (x: any) => void >x : any diff --git a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js index 4f2e1666275..59b85b2b8cc 100644 --- a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js +++ b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js @@ -1,5 +1,4 @@ //// [transformArrowInBlockScopedLoopVarInitializer.ts] - // https://github.com/Microsoft/TypeScript/issues/11236 while (true) { diff --git a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols index 4c5e2cf686e..c105ad68a3a 100644 --- a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols +++ b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/transformArrowInBlockScopedLoopVarInitializer.ts === - // https://github.com/Microsoft/TypeScript/issues/11236 while (true) { let local = null; ->local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 4, 7)) +>local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 3, 7)) var a = () => local; // <-- Lambda should be converted to function() ->a : Symbol(a, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 5, 7)) ->local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 4, 7)) +>a : Symbol(a, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 4, 7)) +>local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 3, 7)) } diff --git a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types index 6c6769dadbb..bacbb829096 100644 --- a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types +++ b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types @@ -1,5 +1,4 @@ === tests/cases/compiler/transformArrowInBlockScopedLoopVarInitializer.ts === - // https://github.com/Microsoft/TypeScript/issues/11236 while (true) >true : true diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.js b/tests/baselines/reference/transformsElideNullUndefinedType.js index 63bc77559c1..ab0f98bcfc2 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.js +++ b/tests/baselines/reference/transformsElideNullUndefinedType.js @@ -1,5 +1,4 @@ //// [transformsElideNullUndefinedType.ts] - var v0: null; var v1: undefined; diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.symbols b/tests/baselines/reference/transformsElideNullUndefinedType.symbols index b651784a61c..a3e3f60aa64 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.symbols +++ b/tests/baselines/reference/transformsElideNullUndefinedType.symbols @@ -1,143 +1,142 @@ === tests/cases/compiler/transformsElideNullUndefinedType.ts === - var v0: null; ->v0 : Symbol(v0, Decl(transformsElideNullUndefinedType.ts, 1, 3)) +>v0 : Symbol(v0, Decl(transformsElideNullUndefinedType.ts, 0, 3)) var v1: undefined; ->v1 : Symbol(v1, Decl(transformsElideNullUndefinedType.ts, 2, 3)) +>v1 : Symbol(v1, Decl(transformsElideNullUndefinedType.ts, 1, 3)) function f0(): null { return null; } ->f0 : Symbol(f0, Decl(transformsElideNullUndefinedType.ts, 2, 18)) +>f0 : Symbol(f0, Decl(transformsElideNullUndefinedType.ts, 1, 18)) function f1(): undefined { return undefined; } ->f1 : Symbol(f1, Decl(transformsElideNullUndefinedType.ts, 4, 36)) +>f1 : Symbol(f1, Decl(transformsElideNullUndefinedType.ts, 3, 36)) >undefined : Symbol(undefined) var f2 = function (): null { return null; } ->f2 : Symbol(f2, Decl(transformsElideNullUndefinedType.ts, 7, 3)) +>f2 : Symbol(f2, Decl(transformsElideNullUndefinedType.ts, 6, 3)) var f3 = function (): undefined { return undefined; } ->f3 : Symbol(f3, Decl(transformsElideNullUndefinedType.ts, 8, 3)) +>f3 : Symbol(f3, Decl(transformsElideNullUndefinedType.ts, 7, 3)) >undefined : Symbol(undefined) var f4 = (): null => null; ->f4 : Symbol(f4, Decl(transformsElideNullUndefinedType.ts, 10, 3)) +>f4 : Symbol(f4, Decl(transformsElideNullUndefinedType.ts, 9, 3)) var f5 = (): undefined => undefined; ->f5 : Symbol(f5, Decl(transformsElideNullUndefinedType.ts, 11, 3)) +>f5 : Symbol(f5, Decl(transformsElideNullUndefinedType.ts, 10, 3)) >undefined : Symbol(undefined) function f6(p0: null) { } ->f6 : Symbol(f6, Decl(transformsElideNullUndefinedType.ts, 11, 36)) ->p0 : Symbol(p0, Decl(transformsElideNullUndefinedType.ts, 13, 12)) +>f6 : Symbol(f6, Decl(transformsElideNullUndefinedType.ts, 10, 36)) +>p0 : Symbol(p0, Decl(transformsElideNullUndefinedType.ts, 12, 12)) function f7(p1: undefined) { } ->f7 : Symbol(f7, Decl(transformsElideNullUndefinedType.ts, 13, 25)) ->p1 : Symbol(p1, Decl(transformsElideNullUndefinedType.ts, 14, 12)) +>f7 : Symbol(f7, Decl(transformsElideNullUndefinedType.ts, 12, 25)) +>p1 : Symbol(p1, Decl(transformsElideNullUndefinedType.ts, 13, 12)) var f8 = function (p2: null) { } ->f8 : Symbol(f8, Decl(transformsElideNullUndefinedType.ts, 16, 3)) ->p2 : Symbol(p2, Decl(transformsElideNullUndefinedType.ts, 16, 19)) +>f8 : Symbol(f8, Decl(transformsElideNullUndefinedType.ts, 15, 3)) +>p2 : Symbol(p2, Decl(transformsElideNullUndefinedType.ts, 15, 19)) var f9 = function (p3: undefined) { } ->f9 : Symbol(f9, Decl(transformsElideNullUndefinedType.ts, 17, 3)) ->p3 : Symbol(p3, Decl(transformsElideNullUndefinedType.ts, 17, 19)) +>f9 : Symbol(f9, Decl(transformsElideNullUndefinedType.ts, 16, 3)) +>p3 : Symbol(p3, Decl(transformsElideNullUndefinedType.ts, 16, 19)) var f10 = (p4: null) => { } ->f10 : Symbol(f10, Decl(transformsElideNullUndefinedType.ts, 19, 3)) ->p4 : Symbol(p4, Decl(transformsElideNullUndefinedType.ts, 19, 11)) +>f10 : Symbol(f10, Decl(transformsElideNullUndefinedType.ts, 18, 3)) +>p4 : Symbol(p4, Decl(transformsElideNullUndefinedType.ts, 18, 11)) var f11 = (p5: undefined) => { } ->f11 : Symbol(f11, Decl(transformsElideNullUndefinedType.ts, 20, 3)) ->p5 : Symbol(p5, Decl(transformsElideNullUndefinedType.ts, 20, 11)) +>f11 : Symbol(f11, Decl(transformsElideNullUndefinedType.ts, 19, 3)) +>p5 : Symbol(p5, Decl(transformsElideNullUndefinedType.ts, 19, 11)) class C1 { ->C1 : Symbol(C1, Decl(transformsElideNullUndefinedType.ts, 20, 32)) +>C1 : Symbol(C1, Decl(transformsElideNullUndefinedType.ts, 19, 32)) m0(): null { return null; } ->m0 : Symbol(C1.m0, Decl(transformsElideNullUndefinedType.ts, 22, 10)) +>m0 : Symbol(C1.m0, Decl(transformsElideNullUndefinedType.ts, 21, 10)) m1(): undefined { return undefined; } ->m1 : Symbol(C1.m1, Decl(transformsElideNullUndefinedType.ts, 23, 31)) +>m1 : Symbol(C1.m1, Decl(transformsElideNullUndefinedType.ts, 22, 31)) >undefined : Symbol(undefined) m3(p6: null) { } ->m3 : Symbol(C1.m3, Decl(transformsElideNullUndefinedType.ts, 24, 41)) ->p6 : Symbol(p6, Decl(transformsElideNullUndefinedType.ts, 26, 7)) +>m3 : Symbol(C1.m3, Decl(transformsElideNullUndefinedType.ts, 23, 41)) +>p6 : Symbol(p6, Decl(transformsElideNullUndefinedType.ts, 25, 7)) m4(p7: undefined) { } ->m4 : Symbol(C1.m4, Decl(transformsElideNullUndefinedType.ts, 26, 20)) ->p7 : Symbol(p7, Decl(transformsElideNullUndefinedType.ts, 27, 7)) +>m4 : Symbol(C1.m4, Decl(transformsElideNullUndefinedType.ts, 25, 20)) +>p7 : Symbol(p7, Decl(transformsElideNullUndefinedType.ts, 26, 7)) get a0(): null { return null; } ->a0 : Symbol(C1.a0, Decl(transformsElideNullUndefinedType.ts, 27, 25)) +>a0 : Symbol(C1.a0, Decl(transformsElideNullUndefinedType.ts, 26, 25)) get a1(): undefined { return undefined; } ->a1 : Symbol(C1.a1, Decl(transformsElideNullUndefinedType.ts, 29, 35)) +>a1 : Symbol(C1.a1, Decl(transformsElideNullUndefinedType.ts, 28, 35)) >undefined : Symbol(undefined) set a2(p8: null) { } ->a2 : Symbol(C1.a2, Decl(transformsElideNullUndefinedType.ts, 30, 45)) ->p8 : Symbol(p8, Decl(transformsElideNullUndefinedType.ts, 32, 11)) +>a2 : Symbol(C1.a2, Decl(transformsElideNullUndefinedType.ts, 29, 45)) +>p8 : Symbol(p8, Decl(transformsElideNullUndefinedType.ts, 31, 11)) set a3(p9: undefined) { } ->a3 : Symbol(C1.a3, Decl(transformsElideNullUndefinedType.ts, 32, 24)) ->p9 : Symbol(p9, Decl(transformsElideNullUndefinedType.ts, 33, 11)) +>a3 : Symbol(C1.a3, Decl(transformsElideNullUndefinedType.ts, 31, 24)) +>p9 : Symbol(p9, Decl(transformsElideNullUndefinedType.ts, 32, 11)) } class C2 { constructor(p10: null) { } } ->C2 : Symbol(C2, Decl(transformsElideNullUndefinedType.ts, 34, 1)) ->p10 : Symbol(p10, Decl(transformsElideNullUndefinedType.ts, 36, 23)) +>C2 : Symbol(C2, Decl(transformsElideNullUndefinedType.ts, 33, 1)) +>p10 : Symbol(p10, Decl(transformsElideNullUndefinedType.ts, 35, 23)) class C3 { constructor(p11: undefined) { } } ->C3 : Symbol(C3, Decl(transformsElideNullUndefinedType.ts, 36, 39)) ->p11 : Symbol(p11, Decl(transformsElideNullUndefinedType.ts, 37, 23)) +>C3 : Symbol(C3, Decl(transformsElideNullUndefinedType.ts, 35, 39)) +>p11 : Symbol(p11, Decl(transformsElideNullUndefinedType.ts, 36, 23)) class C4 { ->C4 : Symbol(C4, Decl(transformsElideNullUndefinedType.ts, 37, 44)) +>C4 : Symbol(C4, Decl(transformsElideNullUndefinedType.ts, 36, 44)) f1; ->f1 : Symbol(C4.f1, Decl(transformsElideNullUndefinedType.ts, 39, 10)) +>f1 : Symbol(C4.f1, Decl(transformsElideNullUndefinedType.ts, 38, 10)) constructor(p12: null) { } ->p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 41, 16)) +>p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 40, 16)) } class C5 { ->C5 : Symbol(C5, Decl(transformsElideNullUndefinedType.ts, 42, 1)) +>C5 : Symbol(C5, Decl(transformsElideNullUndefinedType.ts, 41, 1)) f2; ->f2 : Symbol(C5.f2, Decl(transformsElideNullUndefinedType.ts, 44, 10)) +>f2 : Symbol(C5.f2, Decl(transformsElideNullUndefinedType.ts, 43, 10)) constructor(p13: undefined) { } ->p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 46, 16)) +>p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 45, 16)) } var C6 = class { constructor(p12: null) { } } ->C6 : Symbol(C6, Decl(transformsElideNullUndefinedType.ts, 49, 3)) ->p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 49, 29)) +>C6 : Symbol(C6, Decl(transformsElideNullUndefinedType.ts, 48, 3)) +>p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 48, 29)) var C7 = class { constructor(p13: undefined) { } } ->C7 : Symbol(C7, Decl(transformsElideNullUndefinedType.ts, 50, 3)) ->p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 50, 29)) +>C7 : Symbol(C7, Decl(transformsElideNullUndefinedType.ts, 49, 3)) +>p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 49, 29)) declare function fn(); ->fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 50, 50)) ->T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 52, 20)) +>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 49, 50)) +>T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 51, 20)) fn(); ->fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 50, 50)) +>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 49, 50)) fn(); ->fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 50, 50)) +>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 49, 50)) declare class D {} ->D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 54, 16)) ->T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 56, 16)) +>D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 53, 16)) +>T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 55, 16)) new D(); ->D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 54, 16)) +>D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 53, 16)) new D(); ->D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 54, 16)) +>D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 53, 16)) diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.types b/tests/baselines/reference/transformsElideNullUndefinedType.types index ffc26ddaa60..825f5fc95f8 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.types +++ b/tests/baselines/reference/transformsElideNullUndefinedType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/transformsElideNullUndefinedType.ts === - var v0: null; >v0 : null >null : null diff --git a/tests/baselines/reference/tsxAttributeErrors.errors.txt b/tests/baselines/reference/tsxAttributeErrors.errors.txt index 50dfd88c527..cd515e40d76 100644 --- a/tests/baselines/reference/tsxAttributeErrors.errors.txt +++ b/tests/baselines/reference/tsxAttributeErrors.errors.txt @@ -1,16 +1,15 @@ -tests/cases/conformance/jsx/tsxAttributeErrors.tsx(15,6): error TS2322: Type '{ text: 42; }' is not assignable to type '{ text?: string; width?: number; }'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(14,6): error TS2322: Type '{ text: 42; }' is not assignable to type '{ text?: string; width?: number; }'. Types of property 'text' are incompatible. Type '42' is not assignable to type 'string'. -tests/cases/conformance/jsx/tsxAttributeErrors.tsx(18,6): error TS2322: Type '{ width: "foo"; }' is not assignable to type '{ text?: string; width?: number; }'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(17,6): error TS2322: Type '{ width: "foo"; }' is not assignable to type '{ text?: string; width?: number; }'. Types of property 'width' are incompatible. Type '"foo"' is not assignable to type 'number'. -tests/cases/conformance/jsx/tsxAttributeErrors.tsx(22,6): error TS2322: Type '{ text: number; }' is not assignable to type '{ text?: string; width?: number; }'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(21,6): error TS2322: Type '{ text: number; }' is not assignable to type '{ text?: string; width?: number; }'. Types of property 'text' are incompatible. Type 'number' is not assignable to type 'string'. ==== tests/cases/conformance/jsx/tsxAttributeErrors.tsx (3 errors) ==== - declare namespace JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeErrors.js b/tests/baselines/reference/tsxAttributeErrors.js index 2ab862e0efe..374418c2525 100644 --- a/tests/baselines/reference/tsxAttributeErrors.js +++ b/tests/baselines/reference/tsxAttributeErrors.js @@ -1,5 +1,4 @@ //// [tsxAttributeErrors.tsx] - declare namespace JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution.js b/tests/baselines/reference/tsxAttributeResolution.js index ed3915b7ff2..73c47a440b7 100644 --- a/tests/baselines/reference/tsxAttributeResolution.js +++ b/tests/baselines/reference/tsxAttributeResolution.js @@ -1,5 +1,4 @@ //// [tsxAttributeResolution.tsx] - declare namespace JSX { interface IntrinsicElements { x: { y: number; z: string; }; diff --git a/tests/baselines/reference/tsxAttributeResolution.symbols b/tests/baselines/reference/tsxAttributeResolution.symbols index bb0c5e7878f..78dbaa0bd11 100644 --- a/tests/baselines/reference/tsxAttributeResolution.symbols +++ b/tests/baselines/reference/tsxAttributeResolution.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/jsx/tsxAttributeResolution.tsx === - declare namespace JSX { >JSX : Symbol(JSX, Decl(tsxAttributeResolution.tsx, 0, 0)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxAttributeResolution.tsx, 1, 23)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxAttributeResolution.tsx, 0, 23)) x: { y: number; z: string; }; ->x : Symbol(IntrinsicElements.x, Decl(tsxAttributeResolution.tsx, 2, 30)) ->y : Symbol(y, Decl(tsxAttributeResolution.tsx, 3, 6)) ->z : Symbol(z, Decl(tsxAttributeResolution.tsx, 3, 17)) +>x : Symbol(IntrinsicElements.x, Decl(tsxAttributeResolution.tsx, 1, 30)) +>y : Symbol(y, Decl(tsxAttributeResolution.tsx, 2, 6)) +>z : Symbol(z, Decl(tsxAttributeResolution.tsx, 2, 17)) } } diff --git a/tests/baselines/reference/tsxAttributeResolution.types b/tests/baselines/reference/tsxAttributeResolution.types index f0adc582944..ef5a9506bd7 100644 --- a/tests/baselines/reference/tsxAttributeResolution.types +++ b/tests/baselines/reference/tsxAttributeResolution.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxAttributeResolution.tsx === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/tsxAttributeResolution10.errors.txt b/tests/baselines/reference/tsxAttributeResolution10.errors.txt index dce068dbb76..3710b583e9b 100644 --- a/tests/baselines/reference/tsxAttributeResolution10.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution10.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/jsx/file.tsx(11,14): error TS2322: Type '{ bar: "world"; ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution10.js b/tests/baselines/reference/tsxAttributeResolution10.js index 235cca0be1c..141743c17bc 100644 --- a/tests/baselines/reference/tsxAttributeResolution10.js +++ b/tests/baselines/reference/tsxAttributeResolution10.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution10.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution11.errors.txt b/tests/baselines/reference/tsxAttributeResolution11.errors.txt index a46bf4ba16f..08a75c3b8bb 100644 --- a/tests/baselines/reference/tsxAttributeResolution11.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution11.errors.txt @@ -3,7 +3,6 @@ tests/cases/conformance/jsx/file.tsx(11,22): error TS2322: Type '{ bar: "world"; ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution11.js b/tests/baselines/reference/tsxAttributeResolution11.js index 03b843c209a..c4d62a7147a 100644 --- a/tests/baselines/reference/tsxAttributeResolution11.js +++ b/tests/baselines/reference/tsxAttributeResolution11.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution11.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution12.errors.txt b/tests/baselines/reference/tsxAttributeResolution12.errors.txt index 041776814ca..3113eb833ba 100644 --- a/tests/baselines/reference/tsxAttributeResolution12.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution12.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/jsx/file.tsx(26,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. +tests/cases/conformance/jsx/file.tsx(25,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. Type '{}' is not assignable to type '{ reqd: any; }'. Property 'reqd' is missing in type '{}'. -tests/cases/conformance/jsx/file.tsx(29,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. +tests/cases/conformance/jsx/file.tsx(28,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. Type '{}' is not assignable to type '{ reqd: any; }'. Property 'reqd' is missing in type '{}'. ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { @@ -21,7 +20,6 @@ tests/cases/conformance/jsx/file.tsx(29,10): error TS2322: Type '{}' is not assi } ==== tests/cases/conformance/jsx/file.tsx (2 errors) ==== - declare class Component { constructor(props?: P, context?: any); setState(f: (prevState: S, props: P) => S, callback?: () => any): void; diff --git a/tests/baselines/reference/tsxAttributeResolution12.js b/tests/baselines/reference/tsxAttributeResolution12.js index 05a854a7cbc..7e648485874 100644 --- a/tests/baselines/reference/tsxAttributeResolution12.js +++ b/tests/baselines/reference/tsxAttributeResolution12.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution12.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { @@ -15,7 +14,6 @@ declare module JSX { } //// [file.tsx] - declare class Component { constructor(props?: P, context?: any); setState(f: (prevState: S, props: P) => S, callback?: () => any): void; diff --git a/tests/baselines/reference/tsxAttributeResolution13.js b/tests/baselines/reference/tsxAttributeResolution13.js index e6c942eb926..475bbd2d6e2 100644 --- a/tests/baselines/reference/tsxAttributeResolution13.js +++ b/tests/baselines/reference/tsxAttributeResolution13.js @@ -1,5 +1,4 @@ //// [test.tsx] - function Test() { } diff --git a/tests/baselines/reference/tsxAttributeResolution13.symbols b/tests/baselines/reference/tsxAttributeResolution13.symbols index a913e50969c..641d7886c7b 100644 --- a/tests/baselines/reference/tsxAttributeResolution13.symbols +++ b/tests/baselines/reference/tsxAttributeResolution13.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - function Test() { } >Test : Symbol(Test, Decl(test.tsx, 0, 0)) diff --git a/tests/baselines/reference/tsxAttributeResolution13.types b/tests/baselines/reference/tsxAttributeResolution13.types index 1a426d86e7d..c523c8a40d0 100644 --- a/tests/baselines/reference/tsxAttributeResolution13.types +++ b/tests/baselines/reference/tsxAttributeResolution13.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - function Test() { } >Test : () => void diff --git a/tests/baselines/reference/tsxAttributeResolution14.errors.txt b/tests/baselines/reference/tsxAttributeResolution14.errors.txt index 79b4a55f102..ada85a7a910 100644 --- a/tests/baselines/reference/tsxAttributeResolution14.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution14.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/jsx/file.tsx(14,28): error TS2322: Type '{ primaryText: 2; }' is not assignable to type 'IProps'. +tests/cases/conformance/jsx/file.tsx(13,28): error TS2322: Type '{ primaryText: 2; }' is not assignable to type 'IProps'. Types of property 'primaryText' are incompatible. Type '2' is not assignable to type 'string'. -tests/cases/conformance/jsx/file.tsx(16,28): error TS2322: Type '{ justRandomProp1: true; primaryText: "hello"; }' is not assignable to type 'IProps'. +tests/cases/conformance/jsx/file.tsx(15,28): error TS2322: Type '{ justRandomProp1: true; primaryText: "hello"; }' is not assignable to type 'IProps'. Property 'justRandomProp1' is incompatible with index signature. Type 'true' is not assignable to type 'string | number'. ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { @@ -17,7 +16,6 @@ tests/cases/conformance/jsx/file.tsx(16,28): error TS2322: Type '{ justRandomPro } ==== tests/cases/conformance/jsx/file.tsx (2 errors) ==== - interface IProps { primaryText: string, [propName: string]: string | number diff --git a/tests/baselines/reference/tsxAttributeResolution14.js b/tests/baselines/reference/tsxAttributeResolution14.js index d920179458c..26633239d39 100644 --- a/tests/baselines/reference/tsxAttributeResolution14.js +++ b/tests/baselines/reference/tsxAttributeResolution14.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution14.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { @@ -11,7 +10,6 @@ declare module JSX { } //// [file.tsx] - interface IProps { primaryText: string, [propName: string]: string | number diff --git a/tests/baselines/reference/tsxAttributeResolution15.errors.txt b/tests/baselines/reference/tsxAttributeResolution15.errors.txt index e4d2b6f89a5..7af62ac2b79 100644 --- a/tests/baselines/reference/tsxAttributeResolution15.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution15.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/jsx/file.tsx(12,21): error TS2322: Type '{ prop1: "hello"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. +tests/cases/conformance/jsx/file.tsx(11,21): error TS2322: Type '{ prop1: "hello"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. ==== tests/cases/conformance/jsx/file.tsx (1 errors) ==== - import React = require('react'); class BigGreeter extends React.Component<{ }, {}> { diff --git a/tests/baselines/reference/tsxAttributeResolution15.js b/tests/baselines/reference/tsxAttributeResolution15.js index 110c33593c6..0fbc01e6e0f 100644 --- a/tests/baselines/reference/tsxAttributeResolution15.js +++ b/tests/baselines/reference/tsxAttributeResolution15.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); class BigGreeter extends React.Component<{ }, {}> { diff --git a/tests/baselines/reference/tsxAttributeResolution16.js b/tests/baselines/reference/tsxAttributeResolution16.js index 1182c886b94..1c05446b493 100644 --- a/tests/baselines/reference/tsxAttributeResolution16.js +++ b/tests/baselines/reference/tsxAttributeResolution16.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Address { diff --git a/tests/baselines/reference/tsxAttributeResolution16.symbols b/tests/baselines/reference/tsxAttributeResolution16.symbols index 0c271566de9..d2ae05714ef 100644 --- a/tests/baselines/reference/tsxAttributeResolution16.symbols +++ b/tests/baselines/reference/tsxAttributeResolution16.symbols @@ -1,57 +1,56 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : Symbol(React, Decl(file.tsx, 0, 0)) interface Address { ->Address : Symbol(Address, Decl(file.tsx, 1, 32)) +>Address : Symbol(Address, Decl(file.tsx, 0, 32)) street: string; ->street : Symbol(Address.street, Decl(file.tsx, 3, 19)) +>street : Symbol(Address.street, Decl(file.tsx, 2, 19)) country: string; ->country : Symbol(Address.country, Decl(file.tsx, 4, 17)) +>country : Symbol(Address.country, Decl(file.tsx, 3, 17)) } interface CanadianAddress extends Address { ->CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 6, 1)) ->Address : Symbol(Address, Decl(file.tsx, 1, 32)) +>CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 5, 1)) +>Address : Symbol(Address, Decl(file.tsx, 0, 32)) postalCode: string; ->postalCode : Symbol(CanadianAddress.postalCode, Decl(file.tsx, 8, 43)) +>postalCode : Symbol(CanadianAddress.postalCode, Decl(file.tsx, 7, 43)) } interface AmericanAddress extends Address { ->AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 10, 1)) ->Address : Symbol(Address, Decl(file.tsx, 1, 32)) +>AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 9, 1)) +>Address : Symbol(Address, Decl(file.tsx, 0, 32)) zipCode: string; ->zipCode : Symbol(AmericanAddress.zipCode, Decl(file.tsx, 12, 43)) +>zipCode : Symbol(AmericanAddress.zipCode, Decl(file.tsx, 11, 43)) } type Properties = CanadianAddress | AmericanAddress; ->Properties : Symbol(Properties, Decl(file.tsx, 14, 1)) ->CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 6, 1)) ->AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 10, 1)) +>Properties : Symbol(Properties, Decl(file.tsx, 13, 1)) +>CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 5, 1)) +>AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 9, 1)) export class AddressComp extends React.Component { ->AddressComp : Symbol(AddressComp, Decl(file.tsx, 16, 52)) +>AddressComp : Symbol(AddressComp, Decl(file.tsx, 15, 52)) >React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) >React : Symbol(React, Decl(file.tsx, 0, 0)) >Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) ->Properties : Symbol(Properties, Decl(file.tsx, 14, 1)) +>Properties : Symbol(Properties, Decl(file.tsx, 13, 1)) public render() { ->render : Symbol(AddressComp.render, Decl(file.tsx, 18, 68)) +>render : Symbol(AddressComp.render, Decl(file.tsx, 17, 68)) return null; } } let a = ->a : Symbol(a, Decl(file.tsx, 24, 3)) ->AddressComp : Symbol(AddressComp, Decl(file.tsx, 16, 52)) ->postalCode : Symbol(postalCode, Decl(file.tsx, 24, 20)) ->street : Symbol(street, Decl(file.tsx, 24, 41)) ->country : Symbol(country, Decl(file.tsx, 24, 60)) +>a : Symbol(a, Decl(file.tsx, 23, 3)) +>AddressComp : Symbol(AddressComp, Decl(file.tsx, 15, 52)) +>postalCode : Symbol(postalCode, Decl(file.tsx, 23, 20)) +>street : Symbol(street, Decl(file.tsx, 23, 41)) +>country : Symbol(country, Decl(file.tsx, 23, 60)) diff --git a/tests/baselines/reference/tsxAttributeResolution16.types b/tests/baselines/reference/tsxAttributeResolution16.types index 68134d7ac2d..c7f13ca5096 100644 --- a/tests/baselines/reference/tsxAttributeResolution16.types +++ b/tests/baselines/reference/tsxAttributeResolution16.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : typeof React diff --git a/tests/baselines/reference/tsxAttributeResolution9.errors.txt b/tests/baselines/reference/tsxAttributeResolution9.errors.txt index 670cdd6dfcb..130fe6faab6 100644 --- a/tests/baselines/reference/tsxAttributeResolution9.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution9.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/jsx/file.tsx(9,14): error TS2322: Type '{ foo: 0; }' is ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution9.js b/tests/baselines/reference/tsxAttributeResolution9.js index d7880c820d8..a982fea412b 100644 --- a/tests/baselines/reference/tsxAttributeResolution9.js +++ b/tests/baselines/reference/tsxAttributeResolution9.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution9.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.js b/tests/baselines/reference/tsxDefaultAttributesResolution1.js index 87c079901d9..8d22db3b69f 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution1.js +++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols b/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols index a0efe4f9dbe..900aa7cf842 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols +++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : Symbol(React, Decl(file.tsx, 0, 0)) interface Prop { ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) x: boolean; ->x : Symbol(Prop.x, Decl(file.tsx, 3, 16)) +>x : Symbol(Prop.x, Decl(file.tsx, 2, 16)) } class Poisoned extends React.Component { ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) >React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) >React : Symbol(React, Decl(file.tsx, 0, 0)) >Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) render() { ->render : Symbol(Poisoned.render, Decl(file.tsx, 6, 50)) +>render : Symbol(Poisoned.render, Decl(file.tsx, 5, 50)) return
Hello
; >div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2397, 45)) @@ -27,7 +26,7 @@ class Poisoned extends React.Component { // OK let p = ; ->p : Symbol(p, Decl(file.tsx, 13, 3)) ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) ->x : Symbol(x, Decl(file.tsx, 13, 17)) +>p : Symbol(p, Decl(file.tsx, 12, 3)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) +>x : Symbol(x, Decl(file.tsx, 12, 17)) diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.types b/tests/baselines/reference/tsxDefaultAttributesResolution1.types index 1734380a55d..3167e1bd7ac 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution1.types +++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : typeof React diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.js b/tests/baselines/reference/tsxDefaultAttributesResolution2.js index bc5e6a94ef2..38735169f10 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution2.js +++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols b/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols index 7bcdc7ccfa2..766505b5518 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols +++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : Symbol(React, Decl(file.tsx, 0, 0)) interface Prop { ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) x: true; ->x : Symbol(Prop.x, Decl(file.tsx, 3, 16)) +>x : Symbol(Prop.x, Decl(file.tsx, 2, 16)) } class Poisoned extends React.Component { ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) >React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) >React : Symbol(React, Decl(file.tsx, 0, 0)) >Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) render() { ->render : Symbol(Poisoned.render, Decl(file.tsx, 6, 50)) +>render : Symbol(Poisoned.render, Decl(file.tsx, 5, 50)) return
Hello
; >div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2397, 45)) @@ -27,7 +26,7 @@ class Poisoned extends React.Component { // OK let p = ; ->p : Symbol(p, Decl(file.tsx, 13, 3)) ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) ->x : Symbol(x, Decl(file.tsx, 13, 17)) +>p : Symbol(p, Decl(file.tsx, 12, 3)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) +>x : Symbol(x, Decl(file.tsx, 12, 17)) diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.types b/tests/baselines/reference/tsxDefaultAttributesResolution2.types index ab2bc0c7da6..4b6ceaf0e15 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution2.types +++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : typeof React diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt b/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt index bfb780d2024..cb946258827 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt +++ b/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/jsx/file.tsx(14,19): error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & Prop & { children?: ReactNode; }'. +tests/cases/conformance/jsx/file.tsx(13,19): error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & Prop & { children?: ReactNode; }'. Type '{ x: true; }' is not assignable to type 'Prop'. Types of property 'x' are incompatible. Type 'true' is not assignable to type 'false'. ==== tests/cases/conformance/jsx/file.tsx (1 errors) ==== - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution3.js b/tests/baselines/reference/tsxDefaultAttributesResolution3.js index 82d940ff580..14da51516b5 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution3.js +++ b/tests/baselines/reference/tsxDefaultAttributesResolution3.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultImports.js b/tests/baselines/reference/tsxDefaultImports.js index c918efb5f4f..a6c1a4217a3 100644 --- a/tests/baselines/reference/tsxDefaultImports.js +++ b/tests/baselines/reference/tsxDefaultImports.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/tsxDefaultImports.ts] //// //// [a.ts] - enum SomeEnum { one, } diff --git a/tests/baselines/reference/tsxDefaultImports.symbols b/tests/baselines/reference/tsxDefaultImports.symbols index e42392e24aa..2c47e1e30f3 100644 --- a/tests/baselines/reference/tsxDefaultImports.symbols +++ b/tests/baselines/reference/tsxDefaultImports.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/a.ts === - enum SomeEnum { >SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0)) one, ->one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15)) +>one : Symbol(SomeEnum.one, Decl(a.ts, 0, 15)) } export default class SomeClass { ->SomeClass : Symbol(SomeClass, Decl(a.ts, 3, 1)) +>SomeClass : Symbol(SomeClass, Decl(a.ts, 2, 1)) public static E = SomeEnum; ->E : Symbol(SomeClass.E, Decl(a.ts, 4, 32)) +>E : Symbol(SomeClass.E, Decl(a.ts, 3, 32)) >SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0)) } @@ -21,9 +20,9 @@ import {default as Def} from "./a" let a = Def.E.one; >a : Symbol(a, Decl(b.ts, 1, 3)) ->Def.E.one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15)) ->Def.E : Symbol(Def.E, Decl(a.ts, 4, 32)) +>Def.E.one : Symbol(SomeEnum.one, Decl(a.ts, 0, 15)) +>Def.E : Symbol(Def.E, Decl(a.ts, 3, 32)) >Def : Symbol(Def, Decl(b.ts, 0, 8)) ->E : Symbol(Def.E, Decl(a.ts, 4, 32)) ->one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15)) +>E : Symbol(Def.E, Decl(a.ts, 3, 32)) +>one : Symbol(SomeEnum.one, Decl(a.ts, 0, 15)) diff --git a/tests/baselines/reference/tsxDefaultImports.types b/tests/baselines/reference/tsxDefaultImports.types index a9bdedf3efd..08c00256e0e 100644 --- a/tests/baselines/reference/tsxDefaultImports.types +++ b/tests/baselines/reference/tsxDefaultImports.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - enum SomeEnum { >SomeEnum : SomeEnum diff --git a/tests/baselines/reference/tsxDynamicTagName1.js b/tests/baselines/reference/tsxDynamicTagName1.js index e77d126dd83..023f6c0cb5c 100644 --- a/tests/baselines/reference/tsxDynamicTagName1.js +++ b/tests/baselines/reference/tsxDynamicTagName1.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName1.tsx] - var CustomTag = "h1"; Hello World // No error diff --git a/tests/baselines/reference/tsxDynamicTagName1.symbols b/tests/baselines/reference/tsxDynamicTagName1.symbols index c3ba6440e48..80601b2655b 100644 --- a/tests/baselines/reference/tsxDynamicTagName1.symbols +++ b/tests/baselines/reference/tsxDynamicTagName1.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/jsx/tsxDynamicTagName1.tsx === - var CustomTag = "h1"; ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 1, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 0, 3)) Hello World // No error ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 1, 3)) ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 1, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 0, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 0, 3)) diff --git a/tests/baselines/reference/tsxDynamicTagName1.types b/tests/baselines/reference/tsxDynamicTagName1.types index def9810e052..716c2569e3b 100644 --- a/tests/baselines/reference/tsxDynamicTagName1.types +++ b/tests/baselines/reference/tsxDynamicTagName1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxDynamicTagName1.tsx === - var CustomTag = "h1"; >CustomTag : string >"h1" : "h1" diff --git a/tests/baselines/reference/tsxDynamicTagName2.errors.txt b/tests/baselines/reference/tsxDynamicTagName2.errors.txt index 008a013e379..3c91cd80f3c 100644 --- a/tests/baselines/reference/tsxDynamicTagName2.errors.txt +++ b/tests/baselines/reference/tsxDynamicTagName2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(10,1): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. -tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(10,25): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. +tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(9,1): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. +tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(9,25): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. ==== tests/cases/conformance/jsx/tsxDynamicTagName2.tsx (2 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName2.js b/tests/baselines/reference/tsxDynamicTagName2.js index 7fb7bb1a965..159a91fceed 100644 --- a/tests/baselines/reference/tsxDynamicTagName2.js +++ b/tests/baselines/reference/tsxDynamicTagName2.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName2.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName3.errors.txt b/tests/baselines/reference/tsxDynamicTagName3.errors.txt index 40c10c63f53..406a12bd14f 100644 --- a/tests/baselines/reference/tsxDynamicTagName3.errors.txt +++ b/tests/baselines/reference/tsxDynamicTagName3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/jsx/tsxDynamicTagName3.tsx(10,1): error TS2339: Property 'h1' does not exist on type 'JSX.IntrinsicElements'. +tests/cases/conformance/jsx/tsxDynamicTagName3.tsx(9,1): error TS2339: Property 'h1' does not exist on type 'JSX.IntrinsicElements'. ==== tests/cases/conformance/jsx/tsxDynamicTagName3.tsx (1 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName3.js b/tests/baselines/reference/tsxDynamicTagName3.js index 63c2a0a398b..236dccaf0cd 100644 --- a/tests/baselines/reference/tsxDynamicTagName3.js +++ b/tests/baselines/reference/tsxDynamicTagName3.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName3.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName4.js b/tests/baselines/reference/tsxDynamicTagName4.js index e708273237d..3207df9d549 100644 --- a/tests/baselines/reference/tsxDynamicTagName4.js +++ b/tests/baselines/reference/tsxDynamicTagName4.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName4.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName4.symbols b/tests/baselines/reference/tsxDynamicTagName4.symbols index 3f0fe57ce1f..3074bc754f2 100644 --- a/tests/baselines/reference/tsxDynamicTagName4.symbols +++ b/tests/baselines/reference/tsxDynamicTagName4.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/jsx/tsxDynamicTagName4.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(tsxDynamicTagName4.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(tsxDynamicTagName4.tsx, 1, 20)) +>Element : Symbol(Element, Decl(tsxDynamicTagName4.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName4.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName4.tsx, 1, 22)) div: any ->div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName4.tsx, 3, 30)) +>div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName4.tsx, 2, 30)) h1: any ->h1 : Symbol(IntrinsicElements.h1, Decl(tsxDynamicTagName4.tsx, 4, 10)) +>h1 : Symbol(IntrinsicElements.h1, Decl(tsxDynamicTagName4.tsx, 3, 10)) } } var CustomTag: "h1" = "h1"; ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 9, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 8, 3)) Hello World ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 9, 3)) ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 9, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 8, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 8, 3)) diff --git a/tests/baselines/reference/tsxDynamicTagName4.types b/tests/baselines/reference/tsxDynamicTagName4.types index 3a9a34f2898..c857b2ee9f9 100644 --- a/tests/baselines/reference/tsxDynamicTagName4.types +++ b/tests/baselines/reference/tsxDynamicTagName4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxDynamicTagName4.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxDynamicTagName5.js b/tests/baselines/reference/tsxDynamicTagName5.js index 4dd03843f15..1aa3650a963 100644 --- a/tests/baselines/reference/tsxDynamicTagName5.js +++ b/tests/baselines/reference/tsxDynamicTagName5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName5.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName5.symbols b/tests/baselines/reference/tsxDynamicTagName5.symbols index 9abac5521c9..a37ac84b446 100644 --- a/tests/baselines/reference/tsxDynamicTagName5.symbols +++ b/tests/baselines/reference/tsxDynamicTagName5.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -13,9 +12,9 @@ import * as React from 'react'; export class Text extends React.Component<{}, {}> { >Text : Symbol(Text, Decl(app.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) _tagName: string = 'div'; >_tagName : Symbol(Text._tagName, Decl(app.tsx, 2, 51)) diff --git a/tests/baselines/reference/tsxDynamicTagName5.types b/tests/baselines/reference/tsxDynamicTagName5.types index dbc01e89483..b746be2e88e 100644 --- a/tests/baselines/reference/tsxDynamicTagName5.types +++ b/tests/baselines/reference/tsxDynamicTagName5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxDynamicTagName6.js b/tests/baselines/reference/tsxDynamicTagName6.js index a7ec12b50b7..373070393f6 100644 --- a/tests/baselines/reference/tsxDynamicTagName6.js +++ b/tests/baselines/reference/tsxDynamicTagName6.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName6.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName6.symbols b/tests/baselines/reference/tsxDynamicTagName6.symbols index f1afd91eacb..700deec00a1 100644 --- a/tests/baselines/reference/tsxDynamicTagName6.symbols +++ b/tests/baselines/reference/tsxDynamicTagName6.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/jsx/tsxDynamicTagName6.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(tsxDynamicTagName6.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(tsxDynamicTagName6.tsx, 1, 20)) +>Element : Symbol(Element, Decl(tsxDynamicTagName6.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName6.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName6.tsx, 1, 22)) div: any ->div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName6.tsx, 3, 30)) +>div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName6.tsx, 2, 30)) } } const t = {tag:'h1'} ->t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 8, 5)) ->tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 8, 11)) +>t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 7, 5)) +>tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 7, 11)) const foo = // No error ->foo : Symbol(foo, Decl(tsxDynamicTagName6.tsx, 9, 5)) ->t.tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 8, 11)) ->t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 8, 5)) ->tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 8, 11)) +>foo : Symbol(foo, Decl(tsxDynamicTagName6.tsx, 8, 5)) +>t.tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 7, 11)) +>t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 7, 5)) +>tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 7, 11)) diff --git a/tests/baselines/reference/tsxDynamicTagName6.types b/tests/baselines/reference/tsxDynamicTagName6.types index b4fbb1ed358..33d75fbca72 100644 --- a/tests/baselines/reference/tsxDynamicTagName6.types +++ b/tests/baselines/reference/tsxDynamicTagName6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxDynamicTagName6.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxDynamicTagName7.errors.txt b/tests/baselines/reference/tsxDynamicTagName7.errors.txt index 19f9bed3c27..3d1ba209c12 100644 --- a/tests/baselines/reference/tsxDynamicTagName7.errors.txt +++ b/tests/baselines/reference/tsxDynamicTagName7.errors.txt @@ -2,7 +2,6 @@ tests/cases/conformance/jsx/app.tsx(8,8): error TS2604: JSX element type 'this' ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName7.js b/tests/baselines/reference/tsxDynamicTagName7.js index f4f230b995a..1bfade5d5da 100644 --- a/tests/baselines/reference/tsxDynamicTagName7.js +++ b/tests/baselines/reference/tsxDynamicTagName7.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName7.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName8.js b/tests/baselines/reference/tsxDynamicTagName8.js index 348574ebf42..34a587c7d19 100644 --- a/tests/baselines/reference/tsxDynamicTagName8.js +++ b/tests/baselines/reference/tsxDynamicTagName8.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName8.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName8.symbols b/tests/baselines/reference/tsxDynamicTagName8.symbols index 87a71e740de..996391941a9 100644 --- a/tests/baselines/reference/tsxDynamicTagName8.symbols +++ b/tests/baselines/reference/tsxDynamicTagName8.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -13,9 +12,9 @@ import * as React from 'react'; export class Text extends React.Component<{}, {}> { >Text : Symbol(Text, Decl(app.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) _tagName: string = 'div'; >_tagName : Symbol(Text._tagName, Decl(app.tsx, 2, 51)) diff --git a/tests/baselines/reference/tsxDynamicTagName8.types b/tests/baselines/reference/tsxDynamicTagName8.types index e2d7956a989..bc7d71e9a66 100644 --- a/tests/baselines/reference/tsxDynamicTagName8.types +++ b/tests/baselines/reference/tsxDynamicTagName8.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxDynamicTagName9.js b/tests/baselines/reference/tsxDynamicTagName9.js index e720b2644a0..e5229f97a39 100644 --- a/tests/baselines/reference/tsxDynamicTagName9.js +++ b/tests/baselines/reference/tsxDynamicTagName9.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName9.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName9.symbols b/tests/baselines/reference/tsxDynamicTagName9.symbols index 436e1205751..bfb97510885 100644 --- a/tests/baselines/reference/tsxDynamicTagName9.symbols +++ b/tests/baselines/reference/tsxDynamicTagName9.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -13,9 +12,9 @@ import * as React from 'react'; export class Text extends React.Component<{}, {}> { >Text : Symbol(Text, Decl(app.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) _tagName: "div" = 'div'; >_tagName : Symbol(Text._tagName, Decl(app.tsx, 2, 51)) diff --git a/tests/baselines/reference/tsxDynamicTagName9.types b/tests/baselines/reference/tsxDynamicTagName9.types index e500d3f0ab1..91290dcc3d8 100644 --- a/tests/baselines/reference/tsxDynamicTagName9.types +++ b/tests/baselines/reference/tsxDynamicTagName9.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxElementResolution.js b/tests/baselines/reference/tsxElementResolution.js index fb606aa4ccc..6b0f49c19b6 100644 --- a/tests/baselines/reference/tsxElementResolution.js +++ b/tests/baselines/reference/tsxElementResolution.js @@ -1,5 +1,4 @@ //// [tsxElementResolution.tsx] - declare namespace JSX { interface IntrinsicElements { foundFirst: { x: string }; diff --git a/tests/baselines/reference/tsxElementResolution.symbols b/tests/baselines/reference/tsxElementResolution.symbols index 4b3fd175e19..f69d17a6d03 100644 --- a/tests/baselines/reference/tsxElementResolution.symbols +++ b/tests/baselines/reference/tsxElementResolution.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/jsx/tsxElementResolution.tsx === - declare namespace JSX { >JSX : Symbol(JSX, Decl(tsxElementResolution.tsx, 0, 0)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxElementResolution.tsx, 1, 23)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxElementResolution.tsx, 0, 23)) foundFirst: { x: string }; ->foundFirst : Symbol(IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 2, 30)) ->x : Symbol(x, Decl(tsxElementResolution.tsx, 3, 15)) +>foundFirst : Symbol(IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 1, 30)) +>x : Symbol(x, Decl(tsxElementResolution.tsx, 2, 15)) 'string_named'; 'var'; @@ -16,38 +15,38 @@ declare namespace JSX { } class foundFirst { } ->foundFirst : Symbol(foundFirst, Decl(tsxElementResolution.tsx, 7, 1)) +>foundFirst : Symbol(foundFirst, Decl(tsxElementResolution.tsx, 6, 1)) class Other {} ->Other : Symbol(Other, Decl(tsxElementResolution.tsx, 9, 20)) +>Other : Symbol(Other, Decl(tsxElementResolution.tsx, 8, 20)) module Dotted { ->Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 10, 14)) +>Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 9, 14)) export class Name { } ->Name : Symbol(Name, Decl(tsxElementResolution.tsx, 12, 15)) +>Name : Symbol(Name, Decl(tsxElementResolution.tsx, 11, 15)) } // Should find the intrinsic element, not the class element var a = ; ->a : Symbol(a, Decl(tsxElementResolution.tsx, 17, 3)) ->foundFirst : Symbol(JSX.IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 2, 30)) ->x : Symbol(x, Decl(tsxElementResolution.tsx, 17, 19)) +>a : Symbol(a, Decl(tsxElementResolution.tsx, 16, 3)) +>foundFirst : Symbol(JSX.IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 1, 30)) +>x : Symbol(x, Decl(tsxElementResolution.tsx, 16, 19)) var b = ; ->b : Symbol(b, Decl(tsxElementResolution.tsx, 18, 3)) ->string_named : Symbol(JSX.IntrinsicElements['string_named'], Decl(tsxElementResolution.tsx, 3, 28)) +>b : Symbol(b, Decl(tsxElementResolution.tsx, 17, 3)) +>string_named : Symbol(JSX.IntrinsicElements['string_named'], Decl(tsxElementResolution.tsx, 2, 28)) // TODO: This should not be a parse error (should // parse a property name here, not identifier) // var c = ; var d = ; ->d : Symbol(d, Decl(tsxElementResolution.tsx, 22, 3)) ->Other : Symbol(Other, Decl(tsxElementResolution.tsx, 9, 20)) +>d : Symbol(d, Decl(tsxElementResolution.tsx, 21, 3)) +>Other : Symbol(Other, Decl(tsxElementResolution.tsx, 8, 20)) var e = ; ->e : Symbol(e, Decl(tsxElementResolution.tsx, 23, 3)) ->Dotted.Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 12, 15)) ->Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 10, 14)) ->Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 12, 15)) +>e : Symbol(e, Decl(tsxElementResolution.tsx, 22, 3)) +>Dotted.Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 11, 15)) +>Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 9, 14)) +>Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 11, 15)) diff --git a/tests/baselines/reference/tsxElementResolution.types b/tests/baselines/reference/tsxElementResolution.types index 891ebc37e5d..df429d1c54d 100644 --- a/tests/baselines/reference/tsxElementResolution.types +++ b/tests/baselines/reference/tsxElementResolution.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxElementResolution.tsx === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/tsxElementResolution17.js b/tests/baselines/reference/tsxElementResolution17.js index 899498caf8d..1f61a441d66 100644 --- a/tests/baselines/reference/tsxElementResolution17.js +++ b/tests/baselines/reference/tsxElementResolution17.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxElementResolution17.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { } diff --git a/tests/baselines/reference/tsxElementResolution17.symbols b/tests/baselines/reference/tsxElementResolution17.symbols index 0225cc35d91..59deba2c300 100644 --- a/tests/baselines/reference/tsxElementResolution17.symbols +++ b/tests/baselines/reference/tsxElementResolution17.symbols @@ -8,32 +8,31 @@ import s2 = require('elements2'); >s2 : Symbol(s2, Decl(consumer.tsx, 2, 33)) ; ->s1.MyElement : Symbol(s1.MyElement, Decl(file.tsx, 6, 28)) +>s1.MyElement : Symbol(s1.MyElement, Decl(file.tsx, 5, 28)) >s1 : Symbol(s1, Decl(consumer.tsx, 0, 0)) ->MyElement : Symbol(s1.MyElement, Decl(file.tsx, 6, 28)) +>MyElement : Symbol(s1.MyElement, Decl(file.tsx, 5, 28)) === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { } ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) } declare module 'elements1' { class MyElement { ->MyElement : Symbol(MyElement, Decl(file.tsx, 6, 28)) +>MyElement : Symbol(MyElement, Decl(file.tsx, 5, 28)) } } declare module 'elements2' { class MyElement { ->MyElement : Symbol(MyElement, Decl(file.tsx, 12, 28)) +>MyElement : Symbol(MyElement, Decl(file.tsx, 11, 28)) } } diff --git a/tests/baselines/reference/tsxElementResolution17.types b/tests/baselines/reference/tsxElementResolution17.types index c68c19f58e7..ab730d7245d 100644 --- a/tests/baselines/reference/tsxElementResolution17.types +++ b/tests/baselines/reference/tsxElementResolution17.types @@ -14,7 +14,6 @@ import s2 = require('elements2'); >MyElement : typeof s1.MyElement === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxElementResolution19.js b/tests/baselines/reference/tsxElementResolution19.js index 02136e782db..d63ab29794d 100644 --- a/tests/baselines/reference/tsxElementResolution19.js +++ b/tests/baselines/reference/tsxElementResolution19.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxElementResolution19.tsx] //// //// [react.d.ts] - declare module "react" { } @@ -13,7 +12,6 @@ declare module JSX { export class MyClass { } //// [file2.tsx] - // Should not elide React import import * as React from 'react'; import {MyClass} from './file1'; diff --git a/tests/baselines/reference/tsxElementResolution19.symbols b/tests/baselines/reference/tsxElementResolution19.symbols index 48aa4f962b6..8313a8aa4be 100644 --- a/tests/baselines/reference/tsxElementResolution19.symbols +++ b/tests/baselines/reference/tsxElementResolution19.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/jsx/react.d.ts === - -No type information for this code.declare module "react" { +declare module "react" { No type information for this code. No type information for this code.} No type information for this code. @@ -15,14 +14,13 @@ export class MyClass { } >MyClass : Symbol(MyClass, Decl(file1.tsx, 2, 1)) === tests/cases/conformance/jsx/file2.tsx === - // Should not elide React import import * as React from 'react'; ->React : Symbol(React, Decl(file2.tsx, 2, 6)) +>React : Symbol(React, Decl(file2.tsx, 1, 6)) import {MyClass} from './file1'; ->MyClass : Symbol(MyClass, Decl(file2.tsx, 3, 8)) +>MyClass : Symbol(MyClass, Decl(file2.tsx, 2, 8)) ; ->MyClass : Symbol(MyClass, Decl(file2.tsx, 3, 8)) +>MyClass : Symbol(MyClass, Decl(file2.tsx, 2, 8)) diff --git a/tests/baselines/reference/tsxElementResolution19.types b/tests/baselines/reference/tsxElementResolution19.types index 0fa1eefe5f6..6539bfd5908 100644 --- a/tests/baselines/reference/tsxElementResolution19.types +++ b/tests/baselines/reference/tsxElementResolution19.types @@ -1,6 +1,5 @@ === tests/cases/conformance/jsx/react.d.ts === - -No type information for this code.declare module "react" { +declare module "react" { No type information for this code. No type information for this code.} No type information for this code. @@ -15,7 +14,6 @@ export class MyClass { } >MyClass : MyClass === tests/cases/conformance/jsx/file2.tsx === - // Should not elide React import import * as React from 'react'; >React : typeof React diff --git a/tests/baselines/reference/tsxEmit3.errors.txt b/tests/baselines/reference/tsxEmit3.errors.txt index bef4d8d4efc..aa32c5c9afd 100644 --- a/tests/baselines/reference/tsxEmit3.errors.txt +++ b/tests/baselines/reference/tsxEmit3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/jsx/file.tsx(19,2): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/jsx/file.tsx(23,3): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/jsx/file.tsx(26,3): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/jsx/file.tsx(39,2): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(18,2): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(22,3): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(25,3): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(38,2): error TS2695: Left side of comma operator is unused and has no side effects. ==== tests/cases/conformance/jsx/file.tsx (4 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { } diff --git a/tests/baselines/reference/tsxEmit3.js b/tests/baselines/reference/tsxEmit3.js index bf368f9b262..402782f899d 100644 --- a/tests/baselines/reference/tsxEmit3.js +++ b/tests/baselines/reference/tsxEmit3.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { } diff --git a/tests/baselines/reference/tsxEmit3.js.map b/tests/baselines/reference/tsxEmit3.js.map index 6e12addfb6b..bdada1ee7bb 100644 --- a/tests/baselines/reference/tsxEmit3.js.map +++ b/tests/baselines/reference/tsxEmit3.js.map @@ -1,2 +1,2 @@ //// [file.jsx.map] -{"version":3,"file":"file.jsx","sourceRoot":"","sources":["file.tsx"],"names":[],"mappings":"AAMA,IAAO,CAAC,CAQP;AARD,WAAO,CAAC;IACP;QAAmB;QAAgB,CAAC;QAAC,UAAC;IAAD,CAAC,AAAtC,IAAsC;IAAzB,KAAG,MAAsB,CAAA;IACtC,IAAc,CAAC,CAKd;IALD,WAAc,CAAC;QACd;YAAA;YAAmB,CAAC;YAAD,UAAC;QAAD,CAAC,AAApB,IAAoB;QAAP,KAAG,MAAI,CAAA;QAEpB,WAAW;QACX,gBAAgB;IACjB,CAAC,EALa,CAAC,GAAD,GAAC,KAAD,GAAC,QAKd;AACF,CAAC,EARM,CAAC,KAAD,CAAC,QAQP;AAED,WAAO,CAAC;IACP,aAAa;IACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IAEb,IAAc,CAAC,CAMd;IAND,WAAc,CAAC;QACd,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;QAEb,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IACd,CAAC,EANa,CAAC,GAAD,GAAC,KAAD,GAAC,QAMd;AAEF,CAAC,EAZM,CAAC,KAAD,CAAC,QAYP;AAED,WAAO,CAAC;IACP,eAAe;IACf,EAAA,CAAC,CAAC,GAAG,EAAE,CAAC,EAAA,CAAC,CAAC,GAAG,GAAG,CAAC;AAClB,CAAC,EAHM,CAAC,KAAD,CAAC,QAGP;AAED,WAAO,GAAC;IACP,IAAI,CAAC,GAAG,GAAG,CAAC;IACZ,eAAe;IACf,IAAA,GAAG,EAAE,CAAC,IAAA,GAAG,GAAG,CAAC;AACd,CAAC,EAJM,CAAC,KAAD,CAAC,QAIP"} \ No newline at end of file +{"version":3,"file":"file.jsx","sourceRoot":"","sources":["file.tsx"],"names":[],"mappings":"AAKA,IAAO,CAAC,CAQP;AARD,WAAO,CAAC;IACP;QAAmB;QAAgB,CAAC;QAAC,UAAC;IAAD,CAAC,AAAtC,IAAsC;IAAzB,KAAG,MAAsB,CAAA;IACtC,IAAc,CAAC,CAKd;IALD,WAAc,CAAC;QACd;YAAA;YAAmB,CAAC;YAAD,UAAC;QAAD,CAAC,AAApB,IAAoB;QAAP,KAAG,MAAI,CAAA;QAEpB,WAAW;QACX,gBAAgB;IACjB,CAAC,EALa,CAAC,GAAD,GAAC,KAAD,GAAC,QAKd;AACF,CAAC,EARM,CAAC,KAAD,CAAC,QAQP;AAED,WAAO,CAAC;IACP,aAAa;IACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IAEb,IAAc,CAAC,CAMd;IAND,WAAc,CAAC;QACd,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;QAEb,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IACd,CAAC,EANa,CAAC,GAAD,GAAC,KAAD,GAAC,QAMd;AAEF,CAAC,EAZM,CAAC,KAAD,CAAC,QAYP;AAED,WAAO,CAAC;IACP,eAAe;IACf,EAAA,CAAC,CAAC,GAAG,EAAE,CAAC,EAAA,CAAC,CAAC,GAAG,GAAG,CAAC;AAClB,CAAC,EAHM,CAAC,KAAD,CAAC,QAGP;AAED,WAAO,GAAC;IACP,IAAI,CAAC,GAAG,GAAG,CAAC;IACZ,eAAe;IACf,IAAA,GAAG,EAAE,CAAC,IAAA,GAAG,GAAG,CAAC;AACd,CAAC,EAJM,CAAC,KAAD,CAAC,QAIP"} \ No newline at end of file diff --git a/tests/baselines/reference/tsxEmit3.sourcemap.txt b/tests/baselines/reference/tsxEmit3.sourcemap.txt index d2ccdb264ba..91bc3b839af 100644 --- a/tests/baselines/reference/tsxEmit3.sourcemap.txt +++ b/tests/baselines/reference/tsxEmit3.sourcemap.txt @@ -14,8 +14,7 @@ sourceFile:file.tsx 3 > ^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface Element { } > interface IntrinsicElements { } >} @@ -32,10 +31,10 @@ sourceFile:file.tsx > // Foo, ; > } > } -1 >Emitted(1, 1) Source(7, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(7, 8) + SourceIndex(0) -3 >Emitted(1, 6) Source(7, 9) + SourceIndex(0) -4 >Emitted(1, 7) Source(15, 2) + SourceIndex(0) +1 >Emitted(1, 1) Source(6, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(6, 8) + SourceIndex(0) +3 >Emitted(1, 6) Source(6, 9) + SourceIndex(0) +4 >Emitted(1, 7) Source(14, 2) + SourceIndex(0) --- >>>(function (M) { 1-> @@ -45,22 +44,22 @@ sourceFile:file.tsx 1-> 2 >module 3 > M -1->Emitted(2, 1) Source(7, 1) + SourceIndex(0) -2 >Emitted(2, 12) Source(7, 8) + SourceIndex(0) -3 >Emitted(2, 13) Source(7, 9) + SourceIndex(0) +1->Emitted(2, 1) Source(6, 1) + SourceIndex(0) +2 >Emitted(2, 12) Source(6, 8) + SourceIndex(0) +3 >Emitted(2, 13) Source(6, 9) + SourceIndex(0) --- >>> var Foo = (function () { 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^-> 1-> { > -1->Emitted(3, 5) Source(8, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(7, 2) + SourceIndex(0) --- >>> function Foo() { 1->^^^^^^^^ 2 > ^^-> 1->export class Foo { -1->Emitted(4, 9) Source(8, 21) + SourceIndex(0) +1->Emitted(4, 9) Source(7, 21) + SourceIndex(0) --- >>> } 1->^^^^^^^^ @@ -68,16 +67,16 @@ sourceFile:file.tsx 3 > ^^^^^^^^^^^-> 1->constructor() { 2 > } -1->Emitted(5, 9) Source(8, 37) + SourceIndex(0) -2 >Emitted(5, 10) Source(8, 38) + SourceIndex(0) +1->Emitted(5, 9) Source(7, 37) + SourceIndex(0) +2 >Emitted(5, 10) Source(7, 38) + SourceIndex(0) --- >>> return Foo; 1->^^^^^^^^ 2 > ^^^^^^^^^^ 1-> 2 > } -1->Emitted(6, 9) Source(8, 39) + SourceIndex(0) -2 >Emitted(6, 19) Source(8, 40) + SourceIndex(0) +1->Emitted(6, 9) Source(7, 39) + SourceIndex(0) +2 >Emitted(6, 19) Source(7, 40) + SourceIndex(0) --- >>> }()); 1 >^^^^ @@ -89,10 +88,10 @@ sourceFile:file.tsx 2 > } 3 > 4 > export class Foo { constructor() { } } -1 >Emitted(7, 5) Source(8, 39) + SourceIndex(0) -2 >Emitted(7, 6) Source(8, 40) + SourceIndex(0) -3 >Emitted(7, 6) Source(8, 2) + SourceIndex(0) -4 >Emitted(7, 10) Source(8, 40) + SourceIndex(0) +1 >Emitted(7, 5) Source(7, 39) + SourceIndex(0) +2 >Emitted(7, 6) Source(7, 40) + SourceIndex(0) +3 >Emitted(7, 6) Source(7, 2) + SourceIndex(0) +4 >Emitted(7, 10) Source(7, 40) + SourceIndex(0) --- >>> M.Foo = Foo; 1->^^^^ @@ -103,10 +102,10 @@ sourceFile:file.tsx 2 > Foo 3 > { constructor() { } } 4 > -1->Emitted(8, 5) Source(8, 15) + SourceIndex(0) -2 >Emitted(8, 10) Source(8, 18) + SourceIndex(0) -3 >Emitted(8, 16) Source(8, 40) + SourceIndex(0) -4 >Emitted(8, 17) Source(8, 40) + SourceIndex(0) +1->Emitted(8, 5) Source(7, 15) + SourceIndex(0) +2 >Emitted(8, 10) Source(7, 18) + SourceIndex(0) +3 >Emitted(8, 16) Source(7, 40) + SourceIndex(0) +4 >Emitted(8, 17) Source(7, 40) + SourceIndex(0) --- >>> var S; 1 >^^^^ @@ -124,10 +123,10 @@ sourceFile:file.tsx > // Emit Foo > // Foo, ; > } -1 >Emitted(9, 5) Source(9, 2) + SourceIndex(0) -2 >Emitted(9, 9) Source(9, 16) + SourceIndex(0) -3 >Emitted(9, 10) Source(9, 17) + SourceIndex(0) -4 >Emitted(9, 11) Source(14, 3) + SourceIndex(0) +1 >Emitted(9, 5) Source(8, 2) + SourceIndex(0) +2 >Emitted(9, 9) Source(8, 16) + SourceIndex(0) +3 >Emitted(9, 10) Source(8, 17) + SourceIndex(0) +4 >Emitted(9, 11) Source(13, 3) + SourceIndex(0) --- >>> (function (S) { 1->^^^^ @@ -137,22 +136,22 @@ sourceFile:file.tsx 1-> 2 > export module 3 > S -1->Emitted(10, 5) Source(9, 2) + SourceIndex(0) -2 >Emitted(10, 16) Source(9, 16) + SourceIndex(0) -3 >Emitted(10, 17) Source(9, 17) + SourceIndex(0) +1->Emitted(10, 5) Source(8, 2) + SourceIndex(0) +2 >Emitted(10, 16) Source(8, 16) + SourceIndex(0) +3 >Emitted(10, 17) Source(8, 17) + SourceIndex(0) --- >>> var Bar = (function () { 1->^^^^^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^-> 1-> { > -1->Emitted(11, 9) Source(10, 3) + SourceIndex(0) +1->Emitted(11, 9) Source(9, 3) + SourceIndex(0) --- >>> function Bar() { 1->^^^^^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(12, 13) Source(10, 3) + SourceIndex(0) +1->Emitted(12, 13) Source(9, 3) + SourceIndex(0) --- >>> } 1->^^^^^^^^^^^^ @@ -160,16 +159,16 @@ sourceFile:file.tsx 3 > ^^^^^^^^^^^-> 1->export class Bar { 2 > } -1->Emitted(13, 13) Source(10, 22) + SourceIndex(0) -2 >Emitted(13, 14) Source(10, 23) + SourceIndex(0) +1->Emitted(13, 13) Source(9, 22) + SourceIndex(0) +2 >Emitted(13, 14) Source(9, 23) + SourceIndex(0) --- >>> return Bar; 1->^^^^^^^^^^^^ 2 > ^^^^^^^^^^ 1-> 2 > } -1->Emitted(14, 13) Source(10, 22) + SourceIndex(0) -2 >Emitted(14, 23) Source(10, 23) + SourceIndex(0) +1->Emitted(14, 13) Source(9, 22) + SourceIndex(0) +2 >Emitted(14, 23) Source(9, 23) + SourceIndex(0) --- >>> }()); 1 >^^^^^^^^ @@ -181,10 +180,10 @@ sourceFile:file.tsx 2 > } 3 > 4 > export class Bar { } -1 >Emitted(15, 9) Source(10, 22) + SourceIndex(0) -2 >Emitted(15, 10) Source(10, 23) + SourceIndex(0) -3 >Emitted(15, 10) Source(10, 3) + SourceIndex(0) -4 >Emitted(15, 14) Source(10, 23) + SourceIndex(0) +1 >Emitted(15, 9) Source(9, 22) + SourceIndex(0) +2 >Emitted(15, 10) Source(9, 23) + SourceIndex(0) +3 >Emitted(15, 10) Source(9, 3) + SourceIndex(0) +4 >Emitted(15, 14) Source(9, 23) + SourceIndex(0) --- >>> S.Bar = Bar; 1->^^^^^^^^ @@ -195,10 +194,10 @@ sourceFile:file.tsx 2 > Bar 3 > { } 4 > -1->Emitted(16, 9) Source(10, 16) + SourceIndex(0) -2 >Emitted(16, 14) Source(10, 19) + SourceIndex(0) -3 >Emitted(16, 20) Source(10, 23) + SourceIndex(0) -4 >Emitted(16, 21) Source(10, 23) + SourceIndex(0) +1->Emitted(16, 9) Source(9, 16) + SourceIndex(0) +2 >Emitted(16, 14) Source(9, 19) + SourceIndex(0) +3 >Emitted(16, 20) Source(9, 23) + SourceIndex(0) +4 >Emitted(16, 21) Source(9, 23) + SourceIndex(0) --- >>> // Emit Foo 1 >^^^^^^^^ @@ -208,8 +207,8 @@ sourceFile:file.tsx > > 2 > // Emit Foo -1 >Emitted(17, 9) Source(12, 3) + SourceIndex(0) -2 >Emitted(17, 20) Source(12, 14) + SourceIndex(0) +1 >Emitted(17, 9) Source(11, 3) + SourceIndex(0) +2 >Emitted(17, 20) Source(11, 14) + SourceIndex(0) --- >>> // Foo, ; 1->^^^^^^^^ @@ -218,8 +217,8 @@ sourceFile:file.tsx 1-> > 2 > // Foo, ; -1->Emitted(18, 9) Source(13, 3) + SourceIndex(0) -2 >Emitted(18, 25) Source(13, 19) + SourceIndex(0) +1->Emitted(18, 9) Source(12, 3) + SourceIndex(0) +2 >Emitted(18, 25) Source(12, 19) + SourceIndex(0) --- >>> })(S = M.S || (M.S = {})); 1->^^^^ @@ -246,15 +245,15 @@ sourceFile:file.tsx > // Emit Foo > // Foo, ; > } -1->Emitted(19, 5) Source(14, 2) + SourceIndex(0) -2 >Emitted(19, 6) Source(14, 3) + SourceIndex(0) -3 >Emitted(19, 8) Source(9, 16) + SourceIndex(0) -4 >Emitted(19, 9) Source(9, 17) + SourceIndex(0) -5 >Emitted(19, 12) Source(9, 16) + SourceIndex(0) -6 >Emitted(19, 15) Source(9, 17) + SourceIndex(0) -7 >Emitted(19, 20) Source(9, 16) + SourceIndex(0) -8 >Emitted(19, 23) Source(9, 17) + SourceIndex(0) -9 >Emitted(19, 31) Source(14, 3) + SourceIndex(0) +1->Emitted(19, 5) Source(13, 2) + SourceIndex(0) +2 >Emitted(19, 6) Source(13, 3) + SourceIndex(0) +3 >Emitted(19, 8) Source(8, 16) + SourceIndex(0) +4 >Emitted(19, 9) Source(8, 17) + SourceIndex(0) +5 >Emitted(19, 12) Source(8, 16) + SourceIndex(0) +6 >Emitted(19, 15) Source(8, 17) + SourceIndex(0) +7 >Emitted(19, 20) Source(8, 16) + SourceIndex(0) +8 >Emitted(19, 23) Source(8, 17) + SourceIndex(0) +9 >Emitted(19, 31) Source(13, 3) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -280,13 +279,13 @@ sourceFile:file.tsx > // Foo, ; > } > } -1 >Emitted(20, 1) Source(15, 1) + SourceIndex(0) -2 >Emitted(20, 2) Source(15, 2) + SourceIndex(0) -3 >Emitted(20, 4) Source(7, 8) + SourceIndex(0) -4 >Emitted(20, 5) Source(7, 9) + SourceIndex(0) -5 >Emitted(20, 10) Source(7, 8) + SourceIndex(0) -6 >Emitted(20, 11) Source(7, 9) + SourceIndex(0) -7 >Emitted(20, 19) Source(15, 2) + SourceIndex(0) +1 >Emitted(20, 1) Source(14, 1) + SourceIndex(0) +2 >Emitted(20, 2) Source(14, 2) + SourceIndex(0) +3 >Emitted(20, 4) Source(6, 8) + SourceIndex(0) +4 >Emitted(20, 5) Source(6, 9) + SourceIndex(0) +5 >Emitted(20, 10) Source(6, 8) + SourceIndex(0) +6 >Emitted(20, 11) Source(6, 9) + SourceIndex(0) +7 >Emitted(20, 19) Source(14, 2) + SourceIndex(0) --- >>>(function (M) { 1 > @@ -298,9 +297,9 @@ sourceFile:file.tsx > 2 >module 3 > M -1 >Emitted(21, 1) Source(17, 1) + SourceIndex(0) -2 >Emitted(21, 12) Source(17, 8) + SourceIndex(0) -3 >Emitted(21, 13) Source(17, 9) + SourceIndex(0) +1 >Emitted(21, 1) Source(16, 1) + SourceIndex(0) +2 >Emitted(21, 12) Source(16, 8) + SourceIndex(0) +3 >Emitted(21, 13) Source(16, 9) + SourceIndex(0) --- >>> // Emit M.Foo 1->^^^^ @@ -309,8 +308,8 @@ sourceFile:file.tsx 1-> { > 2 > // Emit M.Foo -1->Emitted(22, 5) Source(18, 2) + SourceIndex(0) -2 >Emitted(22, 18) Source(18, 15) + SourceIndex(0) +1->Emitted(22, 5) Source(17, 2) + SourceIndex(0) +2 >Emitted(22, 18) Source(17, 15) + SourceIndex(0) --- >>> M.Foo, ; 1->^^^^ @@ -332,15 +331,15 @@ sourceFile:file.tsx 7 > Foo 8 > /> 9 > ; -1->Emitted(23, 5) Source(19, 2) + SourceIndex(0) -2 >Emitted(23, 7) Source(19, 2) + SourceIndex(0) -3 >Emitted(23, 10) Source(19, 5) + SourceIndex(0) -4 >Emitted(23, 12) Source(19, 7) + SourceIndex(0) -5 >Emitted(23, 13) Source(19, 8) + SourceIndex(0) -6 >Emitted(23, 15) Source(19, 8) + SourceIndex(0) -7 >Emitted(23, 18) Source(19, 11) + SourceIndex(0) -8 >Emitted(23, 21) Source(19, 14) + SourceIndex(0) -9 >Emitted(23, 22) Source(19, 15) + SourceIndex(0) +1->Emitted(23, 5) Source(18, 2) + SourceIndex(0) +2 >Emitted(23, 7) Source(18, 2) + SourceIndex(0) +3 >Emitted(23, 10) Source(18, 5) + SourceIndex(0) +4 >Emitted(23, 12) Source(18, 7) + SourceIndex(0) +5 >Emitted(23, 13) Source(18, 8) + SourceIndex(0) +6 >Emitted(23, 15) Source(18, 8) + SourceIndex(0) +7 >Emitted(23, 18) Source(18, 11) + SourceIndex(0) +8 >Emitted(23, 21) Source(18, 14) + SourceIndex(0) +9 >Emitted(23, 22) Source(18, 15) + SourceIndex(0) --- >>> var S; 1 >^^^^ @@ -360,10 +359,10 @@ sourceFile:file.tsx > // Emit S.Bar > Bar, ; > } -1 >Emitted(24, 5) Source(21, 2) + SourceIndex(0) -2 >Emitted(24, 9) Source(21, 16) + SourceIndex(0) -3 >Emitted(24, 10) Source(21, 17) + SourceIndex(0) -4 >Emitted(24, 11) Source(27, 3) + SourceIndex(0) +1 >Emitted(24, 5) Source(20, 2) + SourceIndex(0) +2 >Emitted(24, 9) Source(20, 16) + SourceIndex(0) +3 >Emitted(24, 10) Source(20, 17) + SourceIndex(0) +4 >Emitted(24, 11) Source(26, 3) + SourceIndex(0) --- >>> (function (S) { 1->^^^^ @@ -373,9 +372,9 @@ sourceFile:file.tsx 1-> 2 > export module 3 > S -1->Emitted(25, 5) Source(21, 2) + SourceIndex(0) -2 >Emitted(25, 16) Source(21, 16) + SourceIndex(0) -3 >Emitted(25, 17) Source(21, 17) + SourceIndex(0) +1->Emitted(25, 5) Source(20, 2) + SourceIndex(0) +2 >Emitted(25, 16) Source(20, 16) + SourceIndex(0) +3 >Emitted(25, 17) Source(20, 17) + SourceIndex(0) --- >>> // Emit M.Foo 1->^^^^^^^^ @@ -384,8 +383,8 @@ sourceFile:file.tsx 1-> { > 2 > // Emit M.Foo -1->Emitted(26, 9) Source(22, 3) + SourceIndex(0) -2 >Emitted(26, 22) Source(22, 16) + SourceIndex(0) +1->Emitted(26, 9) Source(21, 3) + SourceIndex(0) +2 >Emitted(26, 22) Source(21, 16) + SourceIndex(0) --- >>> M.Foo, ; 1->^^^^^^^^ @@ -407,15 +406,15 @@ sourceFile:file.tsx 7 > Foo 8 > /> 9 > ; -1->Emitted(27, 9) Source(23, 3) + SourceIndex(0) -2 >Emitted(27, 11) Source(23, 3) + SourceIndex(0) -3 >Emitted(27, 14) Source(23, 6) + SourceIndex(0) -4 >Emitted(27, 16) Source(23, 8) + SourceIndex(0) -5 >Emitted(27, 17) Source(23, 9) + SourceIndex(0) -6 >Emitted(27, 19) Source(23, 9) + SourceIndex(0) -7 >Emitted(27, 22) Source(23, 12) + SourceIndex(0) -8 >Emitted(27, 25) Source(23, 15) + SourceIndex(0) -9 >Emitted(27, 26) Source(23, 16) + SourceIndex(0) +1->Emitted(27, 9) Source(22, 3) + SourceIndex(0) +2 >Emitted(27, 11) Source(22, 3) + SourceIndex(0) +3 >Emitted(27, 14) Source(22, 6) + SourceIndex(0) +4 >Emitted(27, 16) Source(22, 8) + SourceIndex(0) +5 >Emitted(27, 17) Source(22, 9) + SourceIndex(0) +6 >Emitted(27, 19) Source(22, 9) + SourceIndex(0) +7 >Emitted(27, 22) Source(22, 12) + SourceIndex(0) +8 >Emitted(27, 25) Source(22, 15) + SourceIndex(0) +9 >Emitted(27, 26) Source(22, 16) + SourceIndex(0) --- >>> // Emit S.Bar 1 >^^^^^^^^ @@ -425,8 +424,8 @@ sourceFile:file.tsx > > 2 > // Emit S.Bar -1 >Emitted(28, 9) Source(25, 3) + SourceIndex(0) -2 >Emitted(28, 22) Source(25, 16) + SourceIndex(0) +1 >Emitted(28, 9) Source(24, 3) + SourceIndex(0) +2 >Emitted(28, 22) Source(24, 16) + SourceIndex(0) --- >>> S.Bar, ; 1->^^^^^^^^ @@ -449,15 +448,15 @@ sourceFile:file.tsx 7 > Bar 8 > /> 9 > ; -1->Emitted(29, 9) Source(26, 3) + SourceIndex(0) -2 >Emitted(29, 11) Source(26, 3) + SourceIndex(0) -3 >Emitted(29, 14) Source(26, 6) + SourceIndex(0) -4 >Emitted(29, 16) Source(26, 8) + SourceIndex(0) -5 >Emitted(29, 17) Source(26, 9) + SourceIndex(0) -6 >Emitted(29, 19) Source(26, 9) + SourceIndex(0) -7 >Emitted(29, 22) Source(26, 12) + SourceIndex(0) -8 >Emitted(29, 25) Source(26, 15) + SourceIndex(0) -9 >Emitted(29, 26) Source(26, 16) + SourceIndex(0) +1->Emitted(29, 9) Source(25, 3) + SourceIndex(0) +2 >Emitted(29, 11) Source(25, 3) + SourceIndex(0) +3 >Emitted(29, 14) Source(25, 6) + SourceIndex(0) +4 >Emitted(29, 16) Source(25, 8) + SourceIndex(0) +5 >Emitted(29, 17) Source(25, 9) + SourceIndex(0) +6 >Emitted(29, 19) Source(25, 9) + SourceIndex(0) +7 >Emitted(29, 22) Source(25, 12) + SourceIndex(0) +8 >Emitted(29, 25) Source(25, 15) + SourceIndex(0) +9 >Emitted(29, 26) Source(25, 16) + SourceIndex(0) --- >>> })(S = M.S || (M.S = {})); 1->^^^^ @@ -485,15 +484,15 @@ sourceFile:file.tsx > // Emit S.Bar > Bar, ; > } -1->Emitted(30, 5) Source(27, 2) + SourceIndex(0) -2 >Emitted(30, 6) Source(27, 3) + SourceIndex(0) -3 >Emitted(30, 8) Source(21, 16) + SourceIndex(0) -4 >Emitted(30, 9) Source(21, 17) + SourceIndex(0) -5 >Emitted(30, 12) Source(21, 16) + SourceIndex(0) -6 >Emitted(30, 15) Source(21, 17) + SourceIndex(0) -7 >Emitted(30, 20) Source(21, 16) + SourceIndex(0) -8 >Emitted(30, 23) Source(21, 17) + SourceIndex(0) -9 >Emitted(30, 31) Source(27, 3) + SourceIndex(0) +1->Emitted(30, 5) Source(26, 2) + SourceIndex(0) +2 >Emitted(30, 6) Source(26, 3) + SourceIndex(0) +3 >Emitted(30, 8) Source(20, 16) + SourceIndex(0) +4 >Emitted(30, 9) Source(20, 17) + SourceIndex(0) +5 >Emitted(30, 12) Source(20, 16) + SourceIndex(0) +6 >Emitted(30, 15) Source(20, 17) + SourceIndex(0) +7 >Emitted(30, 20) Source(20, 16) + SourceIndex(0) +8 >Emitted(30, 23) Source(20, 17) + SourceIndex(0) +9 >Emitted(30, 31) Source(26, 3) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -524,13 +523,13 @@ sourceFile:file.tsx > } > > } -1 >Emitted(31, 1) Source(29, 1) + SourceIndex(0) -2 >Emitted(31, 2) Source(29, 2) + SourceIndex(0) -3 >Emitted(31, 4) Source(17, 8) + SourceIndex(0) -4 >Emitted(31, 5) Source(17, 9) + SourceIndex(0) -5 >Emitted(31, 10) Source(17, 8) + SourceIndex(0) -6 >Emitted(31, 11) Source(17, 9) + SourceIndex(0) -7 >Emitted(31, 19) Source(29, 2) + SourceIndex(0) +1 >Emitted(31, 1) Source(28, 1) + SourceIndex(0) +2 >Emitted(31, 2) Source(28, 2) + SourceIndex(0) +3 >Emitted(31, 4) Source(16, 8) + SourceIndex(0) +4 >Emitted(31, 5) Source(16, 9) + SourceIndex(0) +5 >Emitted(31, 10) Source(16, 8) + SourceIndex(0) +6 >Emitted(31, 11) Source(16, 9) + SourceIndex(0) +7 >Emitted(31, 19) Source(28, 2) + SourceIndex(0) --- >>>(function (M) { 1 > @@ -542,9 +541,9 @@ sourceFile:file.tsx > 2 >module 3 > M -1 >Emitted(32, 1) Source(31, 1) + SourceIndex(0) -2 >Emitted(32, 12) Source(31, 8) + SourceIndex(0) -3 >Emitted(32, 13) Source(31, 9) + SourceIndex(0) +1 >Emitted(32, 1) Source(30, 1) + SourceIndex(0) +2 >Emitted(32, 12) Source(30, 8) + SourceIndex(0) +3 >Emitted(32, 13) Source(30, 9) + SourceIndex(0) --- >>> // Emit M.S.Bar 1->^^^^ @@ -553,8 +552,8 @@ sourceFile:file.tsx 1-> { > 2 > // Emit M.S.Bar -1->Emitted(33, 5) Source(32, 2) + SourceIndex(0) -2 >Emitted(33, 20) Source(32, 17) + SourceIndex(0) +1->Emitted(33, 5) Source(31, 2) + SourceIndex(0) +2 >Emitted(33, 20) Source(31, 17) + SourceIndex(0) --- >>> M.S.Bar, ; 1->^^^^ @@ -584,19 +583,19 @@ sourceFile:file.tsx 11> Bar 12> /> 13> ; -1->Emitted(34, 5) Source(33, 2) + SourceIndex(0) -2 >Emitted(34, 7) Source(33, 2) + SourceIndex(0) -3 >Emitted(34, 8) Source(33, 3) + SourceIndex(0) -4 >Emitted(34, 9) Source(33, 4) + SourceIndex(0) -5 >Emitted(34, 12) Source(33, 7) + SourceIndex(0) -6 >Emitted(34, 14) Source(33, 9) + SourceIndex(0) -7 >Emitted(34, 15) Source(33, 10) + SourceIndex(0) -8 >Emitted(34, 17) Source(33, 10) + SourceIndex(0) -9 >Emitted(34, 18) Source(33, 11) + SourceIndex(0) -10>Emitted(34, 19) Source(33, 12) + SourceIndex(0) -11>Emitted(34, 22) Source(33, 15) + SourceIndex(0) -12>Emitted(34, 25) Source(33, 18) + SourceIndex(0) -13>Emitted(34, 26) Source(33, 19) + SourceIndex(0) +1->Emitted(34, 5) Source(32, 2) + SourceIndex(0) +2 >Emitted(34, 7) Source(32, 2) + SourceIndex(0) +3 >Emitted(34, 8) Source(32, 3) + SourceIndex(0) +4 >Emitted(34, 9) Source(32, 4) + SourceIndex(0) +5 >Emitted(34, 12) Source(32, 7) + SourceIndex(0) +6 >Emitted(34, 14) Source(32, 9) + SourceIndex(0) +7 >Emitted(34, 15) Source(32, 10) + SourceIndex(0) +8 >Emitted(34, 17) Source(32, 10) + SourceIndex(0) +9 >Emitted(34, 18) Source(32, 11) + SourceIndex(0) +10>Emitted(34, 19) Source(32, 12) + SourceIndex(0) +11>Emitted(34, 22) Source(32, 15) + SourceIndex(0) +12>Emitted(34, 25) Source(32, 18) + SourceIndex(0) +13>Emitted(34, 26) Source(32, 19) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -617,13 +616,13 @@ sourceFile:file.tsx > // Emit M.S.Bar > S.Bar, ; > } -1 >Emitted(35, 1) Source(34, 1) + SourceIndex(0) -2 >Emitted(35, 2) Source(34, 2) + SourceIndex(0) -3 >Emitted(35, 4) Source(31, 8) + SourceIndex(0) -4 >Emitted(35, 5) Source(31, 9) + SourceIndex(0) -5 >Emitted(35, 10) Source(31, 8) + SourceIndex(0) -6 >Emitted(35, 11) Source(31, 9) + SourceIndex(0) -7 >Emitted(35, 19) Source(34, 2) + SourceIndex(0) +1 >Emitted(35, 1) Source(33, 1) + SourceIndex(0) +2 >Emitted(35, 2) Source(33, 2) + SourceIndex(0) +3 >Emitted(35, 4) Source(30, 8) + SourceIndex(0) +4 >Emitted(35, 5) Source(30, 9) + SourceIndex(0) +5 >Emitted(35, 10) Source(30, 8) + SourceIndex(0) +6 >Emitted(35, 11) Source(30, 9) + SourceIndex(0) +7 >Emitted(35, 19) Source(33, 2) + SourceIndex(0) --- >>>(function (M_1) { 1 > @@ -635,9 +634,9 @@ sourceFile:file.tsx > 2 >module 3 > M -1 >Emitted(36, 1) Source(36, 1) + SourceIndex(0) -2 >Emitted(36, 12) Source(36, 8) + SourceIndex(0) -3 >Emitted(36, 15) Source(36, 9) + SourceIndex(0) +1 >Emitted(36, 1) Source(35, 1) + SourceIndex(0) +2 >Emitted(36, 12) Source(35, 8) + SourceIndex(0) +3 >Emitted(36, 15) Source(35, 9) + SourceIndex(0) --- >>> var M = 100; 1->^^^^ @@ -654,12 +653,12 @@ sourceFile:file.tsx 4 > = 5 > 100 6 > ; -1->Emitted(37, 5) Source(37, 2) + SourceIndex(0) -2 >Emitted(37, 9) Source(37, 6) + SourceIndex(0) -3 >Emitted(37, 10) Source(37, 7) + SourceIndex(0) -4 >Emitted(37, 13) Source(37, 10) + SourceIndex(0) -5 >Emitted(37, 16) Source(37, 13) + SourceIndex(0) -6 >Emitted(37, 17) Source(37, 14) + SourceIndex(0) +1->Emitted(37, 5) Source(36, 2) + SourceIndex(0) +2 >Emitted(37, 9) Source(36, 6) + SourceIndex(0) +3 >Emitted(37, 10) Source(36, 7) + SourceIndex(0) +4 >Emitted(37, 13) Source(36, 10) + SourceIndex(0) +5 >Emitted(37, 16) Source(36, 13) + SourceIndex(0) +6 >Emitted(37, 17) Source(36, 14) + SourceIndex(0) --- >>> // Emit M_1.Foo 1->^^^^ @@ -668,8 +667,8 @@ sourceFile:file.tsx 1-> > 2 > // Emit M_1.Foo -1->Emitted(38, 5) Source(38, 2) + SourceIndex(0) -2 >Emitted(38, 20) Source(38, 17) + SourceIndex(0) +1->Emitted(38, 5) Source(37, 2) + SourceIndex(0) +2 >Emitted(38, 20) Source(37, 17) + SourceIndex(0) --- >>> M_1.Foo, ; 1->^^^^ @@ -691,15 +690,15 @@ sourceFile:file.tsx 7 > Foo 8 > /> 9 > ; -1->Emitted(39, 5) Source(39, 2) + SourceIndex(0) -2 >Emitted(39, 9) Source(39, 2) + SourceIndex(0) -3 >Emitted(39, 12) Source(39, 5) + SourceIndex(0) -4 >Emitted(39, 14) Source(39, 7) + SourceIndex(0) -5 >Emitted(39, 15) Source(39, 8) + SourceIndex(0) -6 >Emitted(39, 19) Source(39, 8) + SourceIndex(0) -7 >Emitted(39, 22) Source(39, 11) + SourceIndex(0) -8 >Emitted(39, 25) Source(39, 14) + SourceIndex(0) -9 >Emitted(39, 26) Source(39, 15) + SourceIndex(0) +1->Emitted(39, 5) Source(38, 2) + SourceIndex(0) +2 >Emitted(39, 9) Source(38, 2) + SourceIndex(0) +3 >Emitted(39, 12) Source(38, 5) + SourceIndex(0) +4 >Emitted(39, 14) Source(38, 7) + SourceIndex(0) +5 >Emitted(39, 15) Source(38, 8) + SourceIndex(0) +6 >Emitted(39, 19) Source(38, 8) + SourceIndex(0) +7 >Emitted(39, 22) Source(38, 11) + SourceIndex(0) +8 >Emitted(39, 25) Source(38, 14) + SourceIndex(0) +9 >Emitted(39, 26) Source(38, 15) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -722,12 +721,12 @@ sourceFile:file.tsx > // Emit M_1.Foo > Foo, ; > } -1 >Emitted(40, 1) Source(40, 1) + SourceIndex(0) -2 >Emitted(40, 2) Source(40, 2) + SourceIndex(0) -3 >Emitted(40, 4) Source(36, 8) + SourceIndex(0) -4 >Emitted(40, 5) Source(36, 9) + SourceIndex(0) -5 >Emitted(40, 10) Source(36, 8) + SourceIndex(0) -6 >Emitted(40, 11) Source(36, 9) + SourceIndex(0) -7 >Emitted(40, 19) Source(40, 2) + SourceIndex(0) +1 >Emitted(40, 1) Source(39, 1) + SourceIndex(0) +2 >Emitted(40, 2) Source(39, 2) + SourceIndex(0) +3 >Emitted(40, 4) Source(35, 8) + SourceIndex(0) +4 >Emitted(40, 5) Source(35, 9) + SourceIndex(0) +5 >Emitted(40, 10) Source(35, 8) + SourceIndex(0) +6 >Emitted(40, 11) Source(35, 9) + SourceIndex(0) +7 >Emitted(40, 19) Source(39, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=file.jsx.map \ No newline at end of file diff --git a/tests/baselines/reference/tsxErrorRecovery1.errors.txt b/tests/baselines/reference/tsxErrorRecovery1.errors.txt index c368e48ddd1..d7e4f5c55df 100644 --- a/tests/baselines/reference/tsxErrorRecovery1.errors.txt +++ b/tests/baselines/reference/tsxErrorRecovery1.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/jsx/file.tsx(5,11): error TS17008: JSX element 'div' has no corresponding closing tag. -tests/cases/conformance/jsx/file.tsx(5,19): error TS1109: Expression expected. -tests/cases/conformance/jsx/file.tsx(8,11): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/file.tsx(8,12): error TS1005: '}' expected. -tests/cases/conformance/jsx/file.tsx(9,1): error TS1005: ' diff --git a/tests/baselines/reference/tsxErrorRecovery2.js b/tests/baselines/reference/tsxErrorRecovery2.js index be5b6c73424..7e60f3e5390 100644 --- a/tests/baselines/reference/tsxErrorRecovery2.js +++ b/tests/baselines/reference/tsxErrorRecovery2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxErrorRecovery2.tsx] //// //// [file1.tsx] - declare namespace JSX { interface Element { } }
diff --git a/tests/baselines/reference/tsxErrorRecovery3.errors.txt b/tests/baselines/reference/tsxErrorRecovery3.errors.txt index 1c9e7bd8f41..2ee6b582cd3 100644 --- a/tests/baselines/reference/tsxErrorRecovery3.errors.txt +++ b/tests/baselines/reference/tsxErrorRecovery3.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/jsx/file1.tsx(4,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file1.tsx(3,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file1.tsx(3,2): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file1.tsx(4,2): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file1.tsx(5,2): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file1.tsx(6,1): error TS2657: JSX expressions must have one parent element. +tests/cases/conformance/jsx/file1.tsx(5,1): error TS2657: JSX expressions must have one parent element. tests/cases/conformance/jsx/file2.tsx(1,9): error TS2695: Left side of comma operator is unused and has no side effects. tests/cases/conformance/jsx/file2.tsx(1,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file2.tsx(1,21): error TS2304: Cannot find name 'React'. @@ -9,7 +9,6 @@ tests/cases/conformance/jsx/file2.tsx(2,1): error TS2657: JSX expressions must h ==== tests/cases/conformance/jsx/file1.tsx (4 errors) ==== - declare namespace JSX { interface Element { } }
diff --git a/tests/baselines/reference/tsxErrorRecovery3.js b/tests/baselines/reference/tsxErrorRecovery3.js index 0e0d3d072a6..931a309a55e 100644 --- a/tests/baselines/reference/tsxErrorRecovery3.js +++ b/tests/baselines/reference/tsxErrorRecovery3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxErrorRecovery3.tsx] //// //// [file1.tsx] - declare namespace JSX { interface Element { } }
diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.js b/tests/baselines/reference/tsxExternalModuleEmit1.js index c8c64062d13..578d952be98 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit1.js +++ b/tests/baselines/reference/tsxExternalModuleEmit1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.symbols b/tests/baselines/reference/tsxExternalModuleEmit1.symbols index e2d3eee98b0..d9a988aa168 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit1.symbols +++ b/tests/baselines/reference/tsxExternalModuleEmit1.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -17,9 +16,9 @@ import { Button } from './button'; export class App extends React.Component { >App : Symbol(App, Decl(app.tsx, 3, 34)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) render() { >render : Symbol(App.render, Decl(app.tsx, 5, 52)) @@ -36,9 +35,9 @@ import * as React from 'react'; export class Button extends React.Component { >Button : Symbol(Button, Decl(button.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(button.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) render() { >render : Symbol(Button.render, Decl(button.tsx, 2, 55)) diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.types b/tests/baselines/reference/tsxExternalModuleEmit1.types index 7e28c35dd13..7045cd739c1 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit1.types +++ b/tests/baselines/reference/tsxExternalModuleEmit1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.js b/tests/baselines/reference/tsxExternalModuleEmit2.js index aae48021457..adf5ed2aaa6 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.js +++ b/tests/baselines/reference/tsxExternalModuleEmit2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxExternalModuleEmit2.tsx] //// //// [modules.d.ts] - declare module 'mod' { var y: any; export default y; diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.symbols b/tests/baselines/reference/tsxExternalModuleEmit2.symbols index 8f7cfa52136..20ae94fb668 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.symbols +++ b/tests/baselines/reference/tsxExternalModuleEmit2.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/jsx/modules.d.ts === - declare module 'mod' { var y: any; ->y : Symbol(y, Decl(modules.d.ts, 2, 5)) +>y : Symbol(y, Decl(modules.d.ts, 1, 5)) export default y; ->y : Symbol(y, Decl(modules.d.ts, 2, 5)) +>y : Symbol(y, Decl(modules.d.ts, 1, 5)) } === tests/cases/conformance/jsx/app.tsx === diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.types b/tests/baselines/reference/tsxExternalModuleEmit2.types index b4746fe46c7..bb858cdf0c1 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.types +++ b/tests/baselines/reference/tsxExternalModuleEmit2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/modules.d.ts === - declare module 'mod' { var y: any; >y : any diff --git a/tests/baselines/reference/tsxInArrowFunction.js b/tests/baselines/reference/tsxInArrowFunction.js index ba4a0dd1d14..e8b9ff1cc64 100644 --- a/tests/baselines/reference/tsxInArrowFunction.js +++ b/tests/baselines/reference/tsxInArrowFunction.js @@ -1,5 +1,4 @@ //// [tsxInArrowFunction.tsx] - declare namespace JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxInArrowFunction.symbols b/tests/baselines/reference/tsxInArrowFunction.symbols index 9fc928e36e1..e45c428de04 100644 --- a/tests/baselines/reference/tsxInArrowFunction.symbols +++ b/tests/baselines/reference/tsxInArrowFunction.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/jsx/tsxInArrowFunction.tsx === - declare namespace JSX { >JSX : Symbol(JSX, Decl(tsxInArrowFunction.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(tsxInArrowFunction.tsx, 1, 23)) +>Element : Symbol(Element, Decl(tsxInArrowFunction.tsx, 0, 23)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxInArrowFunction.tsx, 2, 25)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxInArrowFunction.tsx, 1, 25)) div: { ->div : Symbol(IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) text?: string; ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 3, 14)) } } } @@ -21,31 +20,31 @@ declare namespace JSX { // didn't work
{() =>
}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 12, 16)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 11, 16)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) // didn't work
{x =>
}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->x : Symbol(x, Decl(tsxInArrowFunction.tsx, 15, 6)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 15, 15)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>x : Symbol(x, Decl(tsxInArrowFunction.tsx, 14, 6)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 14, 15)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) // worked
{() => (
)}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 18, 17)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 17, 17)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) // worked (!)
{() =>
}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 21, 16)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 20, 16)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) diff --git a/tests/baselines/reference/tsxInArrowFunction.types b/tests/baselines/reference/tsxInArrowFunction.types index 76b0d1e1e64..5134ec0e699 100644 --- a/tests/baselines/reference/tsxInArrowFunction.types +++ b/tests/baselines/reference/tsxInArrowFunction.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxInArrowFunction.tsx === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/tsxNoJsx.js b/tests/baselines/reference/tsxNoJsx.js index 37663adf2a7..3f7ba134a50 100644 --- a/tests/baselines/reference/tsxNoJsx.js +++ b/tests/baselines/reference/tsxNoJsx.js @@ -1,5 +1,4 @@ //// [tsxNoJsx.tsx] - ; diff --git a/tests/baselines/reference/tsxNoJsx.symbols b/tests/baselines/reference/tsxNoJsx.symbols index 4492e83cf10..2bf187c99cd 100644 --- a/tests/baselines/reference/tsxNoJsx.symbols +++ b/tests/baselines/reference/tsxNoJsx.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxNoJsx.tsx === - ; >nope : Symbol(unknown) diff --git a/tests/baselines/reference/tsxNoJsx.types b/tests/baselines/reference/tsxNoJsx.types index 52e6769795e..40a2d2609df 100644 --- a/tests/baselines/reference/tsxNoJsx.types +++ b/tests/baselines/reference/tsxNoJsx.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxNoJsx.tsx === - ; > : any >nope : any diff --git a/tests/baselines/reference/tsxPreserveEmit1.js b/tests/baselines/reference/tsxPreserveEmit1.js index 585b603abfb..4ad18d0d790 100644 --- a/tests/baselines/reference/tsxPreserveEmit1.js +++ b/tests/baselines/reference/tsxPreserveEmit1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxPreserveEmit1.tsx] //// //// [react.d.ts] - declare module 'react' { var x: any; export = x; diff --git a/tests/baselines/reference/tsxPreserveEmit1.symbols b/tests/baselines/reference/tsxPreserveEmit1.symbols index b5651d7c38e..d477dcc3d3c 100644 --- a/tests/baselines/reference/tsxPreserveEmit1.symbols +++ b/tests/baselines/reference/tsxPreserveEmit1.symbols @@ -9,7 +9,7 @@ import ReactRouter = require('react-router'); import Route = ReactRouter.Route; >Route : Symbol(Route, Decl(test.tsx, 2, 45)) >ReactRouter : Symbol(ReactRouter, Decl(test.tsx, 1, 32)) ->Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 7, 4)) +>Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 6, 4)) var routes1 = ; >routes1 : Symbol(routes1, Decl(test.tsx, 6, 3)) @@ -32,26 +32,25 @@ module M { } === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { var x: any; ->x : Symbol(x, Decl(react.d.ts, 2, 4)) +>x : Symbol(x, Decl(react.d.ts, 1, 4)) export = x; ->x : Symbol(x, Decl(react.d.ts, 2, 4)) +>x : Symbol(x, Decl(react.d.ts, 1, 4)) } declare module ReactRouter { ->ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 3, 1)) var Route: any; ->Route : Symbol(Route, Decl(react.d.ts, 7, 4)) +>Route : Symbol(Route, Decl(react.d.ts, 6, 4)) interface Thing { } ->Thing : Symbol(Thing, Decl(react.d.ts, 7, 16)) +>Thing : Symbol(Thing, Decl(react.d.ts, 6, 16)) } declare module 'react-router' { export = ReactRouter; ->ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 3, 1)) } diff --git a/tests/baselines/reference/tsxPreserveEmit1.types b/tests/baselines/reference/tsxPreserveEmit1.types index 26da75b39e4..099a184b322 100644 --- a/tests/baselines/reference/tsxPreserveEmit1.types +++ b/tests/baselines/reference/tsxPreserveEmit1.types @@ -34,7 +34,6 @@ module M { } === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { var x: any; >x : any diff --git a/tests/baselines/reference/tsxPreserveEmit2.js b/tests/baselines/reference/tsxPreserveEmit2.js index 6a87da7b285..618b2894968 100644 --- a/tests/baselines/reference/tsxPreserveEmit2.js +++ b/tests/baselines/reference/tsxPreserveEmit2.js @@ -1,6 +1,4 @@ //// [test.tsx] - - var Route: any; var routes1 = ; diff --git a/tests/baselines/reference/tsxPreserveEmit2.symbols b/tests/baselines/reference/tsxPreserveEmit2.symbols index 4013b2e35ea..15b2dd694c3 100644 --- a/tests/baselines/reference/tsxPreserveEmit2.symbols +++ b/tests/baselines/reference/tsxPreserveEmit2.symbols @@ -1,10 +1,8 @@ === tests/cases/conformance/jsx/test.tsx === - - var Route: any; ->Route : Symbol(Route, Decl(test.tsx, 2, 3)) +>Route : Symbol(Route, Decl(test.tsx, 0, 3)) var routes1 = ; ->routes1 : Symbol(routes1, Decl(test.tsx, 3, 3)) ->Route : Symbol(Route, Decl(test.tsx, 2, 3)) +>routes1 : Symbol(routes1, Decl(test.tsx, 1, 3)) +>Route : Symbol(Route, Decl(test.tsx, 0, 3)) diff --git a/tests/baselines/reference/tsxPreserveEmit2.types b/tests/baselines/reference/tsxPreserveEmit2.types index c01f564ff53..9e5aac6600c 100644 --- a/tests/baselines/reference/tsxPreserveEmit2.types +++ b/tests/baselines/reference/tsxPreserveEmit2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - - var Route: any; >Route : any diff --git a/tests/baselines/reference/tsxPreserveEmit3.js b/tests/baselines/reference/tsxPreserveEmit3.js index fdbe8cc2bb4..d886d4169b8 100644 --- a/tests/baselines/reference/tsxPreserveEmit3.js +++ b/tests/baselines/reference/tsxPreserveEmit3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxPreserveEmit3.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxPreserveEmit3.symbols b/tests/baselines/reference/tsxPreserveEmit3.symbols index ab534241049..da163402441 100644 --- a/tests/baselines/reference/tsxPreserveEmit3.symbols +++ b/tests/baselines/reference/tsxPreserveEmit3.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) [s: string]: any; ->s : Symbol(s, Decl(file.tsx, 4, 3)) +>s : Symbol(s, Decl(file.tsx, 3, 3)) } } diff --git a/tests/baselines/reference/tsxPreserveEmit3.types b/tests/baselines/reference/tsxPreserveEmit3.types index 152f742a240..eb0a93b66f2 100644 --- a/tests/baselines/reference/tsxPreserveEmit3.types +++ b/tests/baselines/reference/tsxPreserveEmit3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxReactEmit3.js b/tests/baselines/reference/tsxReactEmit3.js index 155a316e078..c0fcf66cc3f 100644 --- a/tests/baselines/reference/tsxReactEmit3.js +++ b/tests/baselines/reference/tsxReactEmit3.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface Element { } } declare var React: any; diff --git a/tests/baselines/reference/tsxReactEmit3.symbols b/tests/baselines/reference/tsxReactEmit3.symbols index cec45805c1e..2220bbe888a 100644 --- a/tests/baselines/reference/tsxReactEmit3.symbols +++ b/tests/baselines/reference/tsxReactEmit3.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/jsx/test.tsx === - declare module JSX { interface Element { } } >JSX : Symbol(JSX, Decl(test.tsx, 0, 0)) ->Element : Symbol(Element, Decl(test.tsx, 1, 20)) +>Element : Symbol(Element, Decl(test.tsx, 0, 20)) declare var React: any; ->React : Symbol(React, Decl(test.tsx, 2, 11)) +>React : Symbol(React, Decl(test.tsx, 1, 11)) declare var Foo, Bar, baz; ->Foo : Symbol(Foo, Decl(test.tsx, 4, 11)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->baz : Symbol(baz, Decl(test.tsx, 4, 21)) +>Foo : Symbol(Foo, Decl(test.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>baz : Symbol(baz, Decl(test.tsx, 3, 21)) q s ; ->Foo : Symbol(Foo, Decl(test.tsx, 4, 11)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Foo : Symbol(Foo, Decl(test.tsx, 4, 11)) +>Foo : Symbol(Foo, Decl(test.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Foo : Symbol(Foo, Decl(test.tsx, 3, 11)) diff --git a/tests/baselines/reference/tsxReactEmit3.types b/tests/baselines/reference/tsxReactEmit3.types index 8416ec015b2..d6abc2b59d1 100644 --- a/tests/baselines/reference/tsxReactEmit3.types +++ b/tests/baselines/reference/tsxReactEmit3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - declare module JSX { interface Element { } } >JSX : any >Element : Element diff --git a/tests/baselines/reference/tsxReactEmit5.js b/tests/baselines/reference/tsxReactEmit5.js index a1e0c4bdf1a..de1e2bf30e2 100644 --- a/tests/baselines/reference/tsxReactEmit5.js +++ b/tests/baselines/reference/tsxReactEmit5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxReactEmit5.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmit5.symbols b/tests/baselines/reference/tsxReactEmit5.symbols index 533652b0d3c..e80164729cf 100644 --- a/tests/baselines/reference/tsxReactEmit5.symbols +++ b/tests/baselines/reference/tsxReactEmit5.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) [s: string]: any; ->s : Symbol(s, Decl(file.tsx, 4, 3)) +>s : Symbol(s, Decl(file.tsx, 3, 3)) } } @@ -29,7 +28,7 @@ var foo: any; var spread1 =
; >spread1 : Symbol(spread1, Decl(react-consumer.tsx, 4, 3)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) >x : Symbol(x, Decl(react-consumer.tsx, 4, 18)) >foo : Symbol(foo, Decl(react-consumer.tsx, 3, 3)) >y : Symbol(y, Decl(react-consumer.tsx, 4, 32)) diff --git a/tests/baselines/reference/tsxReactEmit5.types b/tests/baselines/reference/tsxReactEmit5.types index fb5e201ca36..f6def92af5b 100644 --- a/tests/baselines/reference/tsxReactEmit5.types +++ b/tests/baselines/reference/tsxReactEmit5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxReactEmit6.js b/tests/baselines/reference/tsxReactEmit6.js index fb76a2e1579..762c231ee30 100644 --- a/tests/baselines/reference/tsxReactEmit6.js +++ b/tests/baselines/reference/tsxReactEmit6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxReactEmit6.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmit6.symbols b/tests/baselines/reference/tsxReactEmit6.symbols index eeae4493b4f..b360bd564ee 100644 --- a/tests/baselines/reference/tsxReactEmit6.symbols +++ b/tests/baselines/reference/tsxReactEmit6.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) [s: string]: any; ->s : Symbol(s, Decl(file.tsx, 4, 3)) +>s : Symbol(s, Decl(file.tsx, 3, 3)) } } @@ -32,7 +31,7 @@ namespace M { var spread1 =
; >spread1 : Symbol(spread1, Decl(react-consumer.tsx, 8, 4)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) >x : Symbol(x, Decl(react-consumer.tsx, 8, 19)) >foo : Symbol(foo, Decl(react-consumer.tsx, 7, 4)) >y : Symbol(y, Decl(react-consumer.tsx, 8, 33)) @@ -40,8 +39,8 @@ namespace M { // Quotes var x =
This "quote" thing
; >x : Symbol(x, Decl(react-consumer.tsx, 11, 4)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) } diff --git a/tests/baselines/reference/tsxReactEmit6.types b/tests/baselines/reference/tsxReactEmit6.types index 7cf08b8f0f5..c92ad2493a6 100644 --- a/tests/baselines/reference/tsxReactEmit6.types +++ b/tests/baselines/reference/tsxReactEmit6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxReactEmit7.errors.txt b/tests/baselines/reference/tsxReactEmit7.errors.txt index d151c2e349c..0dd3130a5f4 100644 --- a/tests/baselines/reference/tsxReactEmit7.errors.txt +++ b/tests/baselines/reference/tsxReactEmit7.errors.txt @@ -1,16 +1,15 @@ +tests/cases/conformance/jsx/file.tsx(8,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(9,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(10,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(11,10): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file.tsx(12,10): error TS2304: Cannot find name 'React'. +tests/cases/conformance/jsx/file.tsx(14,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(15,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(16,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(17,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(18,10): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file.tsx(19,10): error TS2304: Cannot find name 'React'. ==== tests/cases/conformance/jsx/file.tsx (9 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmit7.js b/tests/baselines/reference/tsxReactEmit7.js index c119585c1f6..3597f6f09c2 100644 --- a/tests/baselines/reference/tsxReactEmit7.js +++ b/tests/baselines/reference/tsxReactEmit7.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmitNesting.js b/tests/baselines/reference/tsxReactEmitNesting.js index eaee315c340..5e1f7db39c3 100644 --- a/tests/baselines/reference/tsxReactEmitNesting.js +++ b/tests/baselines/reference/tsxReactEmitNesting.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare var vdom: any; declare var ctrl: any; declare var model: any; diff --git a/tests/baselines/reference/tsxReactEmitNesting.symbols b/tests/baselines/reference/tsxReactEmitNesting.symbols index caf2425491e..9972436ac73 100644 --- a/tests/baselines/reference/tsxReactEmitNesting.symbols +++ b/tests/baselines/reference/tsxReactEmitNesting.symbols @@ -1,27 +1,26 @@ === tests/cases/conformance/jsx/file.tsx === - declare var vdom: any; ->vdom : Symbol(vdom, Decl(file.tsx, 1, 11)) +>vdom : Symbol(vdom, Decl(file.tsx, 0, 11)) declare var ctrl: any; ->ctrl : Symbol(ctrl, Decl(file.tsx, 2, 11)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 1, 11)) declare var model: any; ->model : Symbol(model, Decl(file.tsx, 3, 11)) +>model : Symbol(model, Decl(file.tsx, 2, 11)) // A simple render function with nesting and control statements let render = (ctrl, model) => ->render : Symbol(render, Decl(file.tsx, 6, 3)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) +>render : Symbol(render, Decl(file.tsx, 5, 3)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>model : Symbol(model, Decl(file.tsx, 5, 19))
>section : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 7, 12)) +>class : Symbol(class, Decl(file.tsx, 6, 12))
>header : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 8, 15)) +>class : Symbol(class, Decl(file.tsx, 7, 15))

todos <x>

>h1 : Symbol(unknown) @@ -29,93 +28,93 @@ let render = (ctrl, model) => >input : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 10, 18)) ->autofocus : Symbol(autofocus, Decl(file.tsx, 10, 35)) ->autocomplete : Symbol(autocomplete, Decl(file.tsx, 10, 45)) ->placeholder : Symbol(placeholder, Decl(file.tsx, 10, 64)) ->value : Symbol(value, Decl(file.tsx, 10, 101)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) ->onKeyup : Symbol(onKeyup, Decl(file.tsx, 10, 123)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) +>class : Symbol(class, Decl(file.tsx, 9, 18)) +>autofocus : Symbol(autofocus, Decl(file.tsx, 9, 35)) +>autocomplete : Symbol(autocomplete, Decl(file.tsx, 9, 45)) +>placeholder : Symbol(placeholder, Decl(file.tsx, 9, 64)) +>value : Symbol(value, Decl(file.tsx, 9, 101)) +>model : Symbol(model, Decl(file.tsx, 5, 19)) +>onKeyup : Symbol(onKeyup, Decl(file.tsx, 9, 123)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>model : Symbol(model, Decl(file.tsx, 5, 19))
>header : Symbol(unknown)
>section : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 12, 16)) ->style : Symbol(style, Decl(file.tsx, 12, 29)) ->display : Symbol(display, Decl(file.tsx, 12, 38)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) +>class : Symbol(class, Decl(file.tsx, 11, 16)) +>style : Symbol(style, Decl(file.tsx, 11, 29)) +>display : Symbol(display, Decl(file.tsx, 11, 38)) +>model : Symbol(model, Decl(file.tsx, 5, 19)) +>model : Symbol(model, Decl(file.tsx, 5, 19)) >input : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 13, 18)) ->type : Symbol(type, Decl(file.tsx, 13, 37)) ->onChange : Symbol(onChange, Decl(file.tsx, 13, 53)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) +>class : Symbol(class, Decl(file.tsx, 12, 18)) +>type : Symbol(type, Decl(file.tsx, 12, 37)) +>onChange : Symbol(onChange, Decl(file.tsx, 12, 53)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14))