From 470d1d28ab60b078c1e0ce6146d860454bb16319 Mon Sep 17 00:00:00 2001 From: Jeffrey Morlan Date: Sun, 8 Nov 2015 12:00:27 -0800 Subject: [PATCH 01/51] Fix issue #5444 reportImplementationExpectedError: The next node in the tree is not necessarily consecutive. This happens due to syntax errors, e.g. class C { foo(), foo(); } --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 706ed1c65a3..c13f678261c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11205,7 +11205,7 @@ namespace ts { seen = c === node; } }); - if (subsequentNode) { + if (subsequentNode && subsequentNode.pos === node.end) { if (subsequentNode.kind === node.kind) { const errorNode: Node = (subsequentNode).name || subsequentNode; // TODO(jfreeman): These are methods, so handle computed name case From a32f44f9f4c630c8e644e40bf6c9826b18a420e1 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Mon, 9 Nov 2015 14:24:19 -0800 Subject: [PATCH 02/51] Add command line flag to allow synthetic default exports --- src/compiler/checker.ts | 6 ++- src/compiler/commandLineParser.ts | 5 +++ src/compiler/diagnosticMessages.json | 4 ++ src/compiler/types.ts | 1 + .../allowSyntheticDefaultImports1.js | 22 ++++++++++ .../allowSyntheticDefaultImports1.symbols | 18 ++++++++ .../allowSyntheticDefaultImports1.types | 19 +++++++++ .../allowSyntheticDefaultImports2.js | 40 ++++++++++++++++++ .../allowSyntheticDefaultImports2.symbols | 17 ++++++++ .../allowSyntheticDefaultImports2.types | 18 ++++++++ .../allowSyntheticDefaultImports3.errors.txt | 14 +++++++ .../allowSyntheticDefaultImports3.js | 41 +++++++++++++++++++ .../allowSyntheticDefaultImports4.js | 16 ++++++++ .../allowSyntheticDefaultImports4.symbols | 18 ++++++++ .../allowSyntheticDefaultImports4.types | 19 +++++++++ .../allowSyntheticDefaultImports5.js | 27 ++++++++++++ .../allowSyntheticDefaultImports5.symbols | 18 ++++++++ .../allowSyntheticDefaultImports5.types | 19 +++++++++ .../allowSyntheticDefaultImports6.errors.txt | 15 +++++++ .../allowSyntheticDefaultImports6.js | 27 ++++++++++++ .../compiler/allowSyntheticDefaultImports1.ts | 10 +++++ .../compiler/allowSyntheticDefaultImports2.ts | 9 ++++ .../compiler/allowSyntheticDefaultImports3.ts | 10 +++++ .../compiler/allowSyntheticDefaultImports4.ts | 11 +++++ .../compiler/allowSyntheticDefaultImports5.ts | 10 +++++ .../compiler/allowSyntheticDefaultImports6.ts | 11 +++++ 26 files changed, 424 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports1.js create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports1.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports1.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports2.js create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports2.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports2.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports3.errors.txt create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports3.js create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports4.js create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports4.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports4.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports5.js create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports5.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports5.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports6.errors.txt create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports6.js create mode 100644 tests/cases/compiler/allowSyntheticDefaultImports1.ts create mode 100644 tests/cases/compiler/allowSyntheticDefaultImports2.ts create mode 100644 tests/cases/compiler/allowSyntheticDefaultImports3.ts create mode 100644 tests/cases/compiler/allowSyntheticDefaultImports4.ts create mode 100644 tests/cases/compiler/allowSyntheticDefaultImports5.ts create mode 100644 tests/cases/compiler/allowSyntheticDefaultImports6.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 706ed1c65a3..9dbce88c32b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -46,6 +46,7 @@ namespace ts { const compilerOptions = host.getCompilerOptions(); const languageVersion = compilerOptions.target || ScriptTarget.ES3; const modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None; + const allowSyntheticDefaultImports = compilerOptions.hasOwnProperty("allowSyntheticDefaultImports") ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System; const emitResolver = createResolver(); @@ -730,9 +731,12 @@ namespace ts { const moduleSymbol = resolveExternalModuleName(node, (node.parent).moduleSpecifier); if (moduleSymbol) { const exportDefaultSymbol = resolveSymbol(moduleSymbol.exports["default"]); - if (!exportDefaultSymbol) { + if (!exportDefaultSymbol && !allowSyntheticDefaultImports) { error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol)); } + else if (!exportDefaultSymbol && allowSyntheticDefaultImports) { + return resolveSymbol(moduleSymbol.exports["export="]) || resolveSymbol(moduleSymbol); + } return exportDefaultSymbol; } } diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 3fca97c0450..272f5430b8c 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -279,6 +279,11 @@ namespace ts { name: "forceConsistentCasingInFileNames", type: "boolean", description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file + }, + { + name: "allowSyntheticDefaultImports", + type: "boolean", + description: Diagnostics.Allow_default_imports_from_modules_with_no_default_export } ]; diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index e6008ce3c1e..cdd20b38a69 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2101,6 +2101,10 @@ "category": "Message", "code": 6010 }, + "Allow default imports from modules with no default export": { + "category": "Message", + "code": 6011 + }, "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES2015' (experimental)": { "category": "Message", "code": 6015 diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 679957d1d38..b846dc88aab 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2109,6 +2109,7 @@ namespace ts { noImplicitReturns?: boolean; noFallthroughCasesInSwitch?: boolean; forceConsistentCasingInFileNames?: boolean; + allowSyntheticDefaultImports?: boolean; /* @internal */ stripInternal?: boolean; // Skip checking lib.d.ts to help speed up tests. diff --git a/tests/baselines/reference/allowSyntheticDefaultImports1.js b/tests/baselines/reference/allowSyntheticDefaultImports1.js new file mode 100644 index 00000000000..bc78725cb1c --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports1.js @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/allowSyntheticDefaultImports1.ts] //// + +//// [a.ts] +import Namespace from "./b"; +export var x = new Namespace.Foo(); + +//// [b.ts] +export class Foo { + member: string; +} + + +//// [b.js] +var Foo = (function () { + function Foo() { + } + return Foo; +})(); +exports.Foo = Foo; +//// [a.js] +var b_1 = require("./b"); +exports.x = new b_1["default"].Foo(); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports1.symbols b/tests/baselines/reference/allowSyntheticDefaultImports1.symbols new file mode 100644 index 00000000000..d88a79e1bf2 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports1.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/a.ts === +import Namespace from "./b"; +>Namespace : Symbol(Namespace, Decl(a.ts, 0, 6)) + +export var x = new Namespace.Foo(); +>x : Symbol(x, Decl(a.ts, 1, 10)) +>Namespace.Foo : Symbol(Namespace.Foo, Decl(b.ts, 0, 0)) +>Namespace : Symbol(Namespace, Decl(a.ts, 0, 6)) +>Foo : Symbol(Namespace.Foo, Decl(b.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export class Foo { +>Foo : Symbol(Foo, Decl(b.ts, 0, 0)) + + member: string; +>member : Symbol(member, Decl(b.ts, 0, 18)) +} + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports1.types b/tests/baselines/reference/allowSyntheticDefaultImports1.types new file mode 100644 index 00000000000..c2265d7611b --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports1.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +import Namespace from "./b"; +>Namespace : typeof Namespace + +export var x = new Namespace.Foo(); +>x : Namespace.Foo +>new Namespace.Foo() : Namespace.Foo +>Namespace.Foo : typeof Namespace.Foo +>Namespace : typeof Namespace +>Foo : typeof Namespace.Foo + +=== tests/cases/compiler/b.ts === +export class Foo { +>Foo : Foo + + member: string; +>member : string +} + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports2.js b/tests/baselines/reference/allowSyntheticDefaultImports2.js new file mode 100644 index 00000000000..3c1981bee9b --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports2.js @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/allowSyntheticDefaultImports2.ts] //// + +//// [a.ts] +import Namespace from "./b"; +export var x = new Namespace.Foo(); + +//// [b.ts] +export class Foo { + member: string; +} + +//// [b.js] +System.register([], function(exports_1) { + var Foo; + return { + setters:[], + execute: function() { + Foo = (function () { + function Foo() { + } + return Foo; + })(); + exports_1("Foo", Foo); + } + } +}); +//// [a.js] +System.register(["./b"], function(exports_1) { + var b_1; + var x; + return { + setters:[ + function (b_1_1) { + b_1 = b_1_1; + }], + execute: function() { + exports_1("x", x = new b_1["default"].Foo()); + } + } +}); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports2.symbols b/tests/baselines/reference/allowSyntheticDefaultImports2.symbols new file mode 100644 index 00000000000..cea6145fbd6 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports2.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/a.ts === +import Namespace from "./b"; +>Namespace : Symbol(Namespace, Decl(a.ts, 0, 6)) + +export var x = new Namespace.Foo(); +>x : Symbol(x, Decl(a.ts, 1, 10)) +>Namespace.Foo : Symbol(Namespace.Foo, Decl(b.ts, 0, 0)) +>Namespace : Symbol(Namespace, Decl(a.ts, 0, 6)) +>Foo : Symbol(Namespace.Foo, Decl(b.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export class Foo { +>Foo : Symbol(Foo, Decl(b.ts, 0, 0)) + + member: string; +>member : Symbol(member, Decl(b.ts, 0, 18)) +} diff --git a/tests/baselines/reference/allowSyntheticDefaultImports2.types b/tests/baselines/reference/allowSyntheticDefaultImports2.types new file mode 100644 index 00000000000..c40fbc7e988 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports2.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/a.ts === +import Namespace from "./b"; +>Namespace : typeof Namespace + +export var x = new Namespace.Foo(); +>x : Namespace.Foo +>new Namespace.Foo() : Namespace.Foo +>Namespace.Foo : typeof Namespace.Foo +>Namespace : typeof Namespace +>Foo : typeof Namespace.Foo + +=== tests/cases/compiler/b.ts === +export class Foo { +>Foo : Foo + + member: string; +>member : string +} diff --git a/tests/baselines/reference/allowSyntheticDefaultImports3.errors.txt b/tests/baselines/reference/allowSyntheticDefaultImports3.errors.txt new file mode 100644 index 00000000000..551355e5cce --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports3.errors.txt @@ -0,0 +1,14 @@ +tests/cases/compiler/a.ts(1,8): error TS1192: Module '"tests/cases/compiler/b"' has no default export. + + +==== tests/cases/compiler/a.ts (1 errors) ==== + import Namespace from "./b"; + ~~~~~~~~~ +!!! error TS1192: Module '"tests/cases/compiler/b"' has no default export. + export var x = new Namespace.Foo(); + +==== tests/cases/compiler/b.ts (0 errors) ==== + export class Foo { + member: string; + } + \ No newline at end of file diff --git a/tests/baselines/reference/allowSyntheticDefaultImports3.js b/tests/baselines/reference/allowSyntheticDefaultImports3.js new file mode 100644 index 00000000000..2345ad65d10 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports3.js @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/allowSyntheticDefaultImports3.ts] //// + +//// [a.ts] +import Namespace from "./b"; +export var x = new Namespace.Foo(); + +//// [b.ts] +export class Foo { + member: string; +} + + +//// [b.js] +System.register([], function(exports_1) { + var Foo; + return { + setters:[], + execute: function() { + Foo = (function () { + function Foo() { + } + return Foo; + })(); + exports_1("Foo", Foo); + } + } +}); +//// [a.js] +System.register(["./b"], function(exports_1) { + var b_1; + var x; + return { + setters:[ + function (b_1_1) { + b_1 = b_1_1; + }], + execute: function() { + exports_1("x", x = new b_1["default"].Foo()); + } + } +}); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports4.js b/tests/baselines/reference/allowSyntheticDefaultImports4.js new file mode 100644 index 00000000000..583d4f0bc92 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports4.js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/allowSyntheticDefaultImports4.ts] //// + +//// [b.d.ts] +declare class Foo { + member: string; +} +export = Foo; + +//// [a.ts] +import Foo from "./b"; +export var x = new Foo(); + + +//// [a.js] +var b_1 = require("./b"); +exports.x = new b_1["default"](); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports4.symbols b/tests/baselines/reference/allowSyntheticDefaultImports4.symbols new file mode 100644 index 00000000000..8edad006c2d --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports4.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/b.d.ts === +declare class Foo { +>Foo : Symbol(Foo, Decl(b.d.ts, 0, 0)) + + member: string; +>member : Symbol(member, Decl(b.d.ts, 0, 19)) +} +export = Foo; +>Foo : Symbol(Foo, Decl(b.d.ts, 0, 0)) + +=== tests/cases/compiler/a.ts === +import Foo from "./b"; +>Foo : Symbol(Foo, Decl(a.ts, 0, 6)) + +export var x = new Foo(); +>x : Symbol(x, Decl(a.ts, 1, 10)) +>Foo : Symbol(Foo, Decl(a.ts, 0, 6)) + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports4.types b/tests/baselines/reference/allowSyntheticDefaultImports4.types new file mode 100644 index 00000000000..5922abeb43f --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports4.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/b.d.ts === +declare class Foo { +>Foo : Foo + + member: string; +>member : string +} +export = Foo; +>Foo : Foo + +=== tests/cases/compiler/a.ts === +import Foo from "./b"; +>Foo : typeof Foo + +export var x = new Foo(); +>x : Foo +>new Foo() : Foo +>Foo : typeof Foo + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports5.js b/tests/baselines/reference/allowSyntheticDefaultImports5.js new file mode 100644 index 00000000000..e1528e27915 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports5.js @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/allowSyntheticDefaultImports5.ts] //// + +//// [b.d.ts] +declare class Foo { + member: string; +} +export = Foo; + +//// [a.ts] +import Foo from "./b"; +export var x = new Foo(); + + +//// [a.js] +System.register(["./b"], function(exports_1) { + var b_1; + var x; + return { + setters:[ + function (b_1_1) { + b_1 = b_1_1; + }], + execute: function() { + exports_1("x", x = new b_1["default"]()); + } + } +}); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports5.symbols b/tests/baselines/reference/allowSyntheticDefaultImports5.symbols new file mode 100644 index 00000000000..8edad006c2d --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports5.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/b.d.ts === +declare class Foo { +>Foo : Symbol(Foo, Decl(b.d.ts, 0, 0)) + + member: string; +>member : Symbol(member, Decl(b.d.ts, 0, 19)) +} +export = Foo; +>Foo : Symbol(Foo, Decl(b.d.ts, 0, 0)) + +=== tests/cases/compiler/a.ts === +import Foo from "./b"; +>Foo : Symbol(Foo, Decl(a.ts, 0, 6)) + +export var x = new Foo(); +>x : Symbol(x, Decl(a.ts, 1, 10)) +>Foo : Symbol(Foo, Decl(a.ts, 0, 6)) + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports5.types b/tests/baselines/reference/allowSyntheticDefaultImports5.types new file mode 100644 index 00000000000..5922abeb43f --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports5.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/b.d.ts === +declare class Foo { +>Foo : Foo + + member: string; +>member : string +} +export = Foo; +>Foo : Foo + +=== tests/cases/compiler/a.ts === +import Foo from "./b"; +>Foo : typeof Foo + +export var x = new Foo(); +>x : Foo +>new Foo() : Foo +>Foo : typeof Foo + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports6.errors.txt b/tests/baselines/reference/allowSyntheticDefaultImports6.errors.txt new file mode 100644 index 00000000000..80b9cf8d074 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports6.errors.txt @@ -0,0 +1,15 @@ +tests/cases/compiler/a.ts(1,8): error TS1192: Module '"tests/cases/compiler/b"' has no default export. + + +==== tests/cases/compiler/b.d.ts (0 errors) ==== + declare class Foo { + member: string; + } + export = Foo; + +==== tests/cases/compiler/a.ts (1 errors) ==== + import Foo from "./b"; + ~~~ +!!! error TS1192: Module '"tests/cases/compiler/b"' has no default export. + export var x = new Foo(); + \ No newline at end of file diff --git a/tests/baselines/reference/allowSyntheticDefaultImports6.js b/tests/baselines/reference/allowSyntheticDefaultImports6.js new file mode 100644 index 00000000000..0e27ce127d8 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports6.js @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/allowSyntheticDefaultImports6.ts] //// + +//// [b.d.ts] +declare class Foo { + member: string; +} +export = Foo; + +//// [a.ts] +import Foo from "./b"; +export var x = new Foo(); + + +//// [a.js] +System.register(["./b"], function(exports_1) { + var b_1; + var x; + return { + setters:[ + function (b_1_1) { + b_1 = b_1_1; + }], + execute: function() { + exports_1("x", x = new b_1["default"]()); + } + } +}); diff --git a/tests/cases/compiler/allowSyntheticDefaultImports1.ts b/tests/cases/compiler/allowSyntheticDefaultImports1.ts new file mode 100644 index 00000000000..4793da79136 --- /dev/null +++ b/tests/cases/compiler/allowSyntheticDefaultImports1.ts @@ -0,0 +1,10 @@ +// @allowSyntheticDefaultImports: true +// @module: commonjs +// @Filename: a.ts +import Namespace from "./b"; +export var x = new Namespace.Foo(); + +// @Filename: b.ts +export class Foo { + member: string; +} diff --git a/tests/cases/compiler/allowSyntheticDefaultImports2.ts b/tests/cases/compiler/allowSyntheticDefaultImports2.ts new file mode 100644 index 00000000000..8fa004be387 --- /dev/null +++ b/tests/cases/compiler/allowSyntheticDefaultImports2.ts @@ -0,0 +1,9 @@ +// @module: system +// @Filename: a.ts +import Namespace from "./b"; +export var x = new Namespace.Foo(); + +// @Filename: b.ts +export class Foo { + member: string; +} \ No newline at end of file diff --git a/tests/cases/compiler/allowSyntheticDefaultImports3.ts b/tests/cases/compiler/allowSyntheticDefaultImports3.ts new file mode 100644 index 00000000000..65d11c892c9 --- /dev/null +++ b/tests/cases/compiler/allowSyntheticDefaultImports3.ts @@ -0,0 +1,10 @@ +// @allowSyntheticDefaultImports: false +// @module: system +// @Filename: a.ts +import Namespace from "./b"; +export var x = new Namespace.Foo(); + +// @Filename: b.ts +export class Foo { + member: string; +} diff --git a/tests/cases/compiler/allowSyntheticDefaultImports4.ts b/tests/cases/compiler/allowSyntheticDefaultImports4.ts new file mode 100644 index 00000000000..1d26c6277c1 --- /dev/null +++ b/tests/cases/compiler/allowSyntheticDefaultImports4.ts @@ -0,0 +1,11 @@ +// @allowSyntheticDefaultImports: true +// @module: commonjs +// @Filename: b.d.ts +declare class Foo { + member: string; +} +export = Foo; + +// @Filename: a.ts +import Foo from "./b"; +export var x = new Foo(); diff --git a/tests/cases/compiler/allowSyntheticDefaultImports5.ts b/tests/cases/compiler/allowSyntheticDefaultImports5.ts new file mode 100644 index 00000000000..30ebba67144 --- /dev/null +++ b/tests/cases/compiler/allowSyntheticDefaultImports5.ts @@ -0,0 +1,10 @@ +// @module: system +// @Filename: b.d.ts +declare class Foo { + member: string; +} +export = Foo; + +// @Filename: a.ts +import Foo from "./b"; +export var x = new Foo(); diff --git a/tests/cases/compiler/allowSyntheticDefaultImports6.ts b/tests/cases/compiler/allowSyntheticDefaultImports6.ts new file mode 100644 index 00000000000..ff0300e30b4 --- /dev/null +++ b/tests/cases/compiler/allowSyntheticDefaultImports6.ts @@ -0,0 +1,11 @@ +// @allowSyntheticDefaultImports: false +// @module: system +// @Filename: b.d.ts +declare class Foo { + member: string; +} +export = Foo; + +// @Filename: a.ts +import Foo from "./b"; +export var x = new Foo(); From 9024032571316f17ccdc80a3392b9d173621babe Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Mon, 9 Nov 2015 15:13:55 -0800 Subject: [PATCH 03/51] use typeof --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9dbce88c32b..102b6b0c670 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -46,7 +46,7 @@ namespace ts { const compilerOptions = host.getCompilerOptions(); const languageVersion = compilerOptions.target || ScriptTarget.ES3; const modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None; - const allowSyntheticDefaultImports = compilerOptions.hasOwnProperty("allowSyntheticDefaultImports") ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System; + const allowSyntheticDefaultImports = typeof compilerOptions.allowSyntheticDefaultImports !== "undefined" ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System; const emitResolver = createResolver(); From c72861ebd77722230c830ee9b31c929001025967 Mon Sep 17 00:00:00 2001 From: Jeffrey Morlan Date: Mon, 9 Nov 2015 21:05:05 -0800 Subject: [PATCH 04/51] Add test case --- .../overloadConsecutiveness.errors.txt | 63 +++++++++++++++++++ .../reference/overloadConsecutiveness.js | 27 ++++++++ .../cases/compiler/overloadConsecutiveness.ts | 11 ++++ 3 files changed, 101 insertions(+) create mode 100644 tests/baselines/reference/overloadConsecutiveness.errors.txt create mode 100644 tests/baselines/reference/overloadConsecutiveness.js create mode 100644 tests/cases/compiler/overloadConsecutiveness.ts diff --git a/tests/baselines/reference/overloadConsecutiveness.errors.txt b/tests/baselines/reference/overloadConsecutiveness.errors.txt new file mode 100644 index 00000000000..59634681c43 --- /dev/null +++ b/tests/baselines/reference/overloadConsecutiveness.errors.txt @@ -0,0 +1,63 @@ +tests/cases/compiler/overloadConsecutiveness.ts(3,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(3,14): error TS1144: '{' or ';' expected. +tests/cases/compiler/overloadConsecutiveness.ts(3,25): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(4,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(4,14): error TS1144: '{' or ';' expected. +tests/cases/compiler/overloadConsecutiveness.ts(5,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(5,17): error TS1128: Declaration or statement expected. +tests/cases/compiler/overloadConsecutiveness.ts(5,28): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(8,2): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(8,6): error TS1144: '{' or ';' expected. +tests/cases/compiler/overloadConsecutiveness.ts(8,8): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(9,2): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(9,6): error TS1144: '{' or ';' expected. +tests/cases/compiler/overloadConsecutiveness.ts(10,2): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/overloadConsecutiveness.ts(10,9): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/overloadConsecutiveness.ts(10,11): error TS2391: Function implementation is missing or not immediately following the declaration. + + +==== tests/cases/compiler/overloadConsecutiveness.ts (16 errors) ==== + // Making sure compiler won't break with declarations that are consecutive in the AST but not consecutive in the source. Syntax errors intentional. + + function f1(), function f1(); + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + ~ +!!! error TS1144: '{' or ';' expected. + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + function f2(), function f2() {} + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + ~ +!!! error TS1144: '{' or ';' expected. + function f3() {}, function f3(); + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + ~ +!!! error TS1128: Declaration or statement expected. + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + + class C { + m1(), m1(); + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + ~ +!!! error TS1144: '{' or ';' expected. + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + m2(), m2() {} + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + ~ +!!! error TS1144: '{' or ';' expected. + m3() {}, m3(); + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + ~ +!!! error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. + ~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + } + \ No newline at end of file diff --git a/tests/baselines/reference/overloadConsecutiveness.js b/tests/baselines/reference/overloadConsecutiveness.js new file mode 100644 index 00000000000..8c0d3d26b72 --- /dev/null +++ b/tests/baselines/reference/overloadConsecutiveness.js @@ -0,0 +1,27 @@ +//// [overloadConsecutiveness.ts] +// Making sure compiler won't break with declarations that are consecutive in the AST but not consecutive in the source. Syntax errors intentional. + +function f1(), function f1(); +function f2(), function f2() {} +function f3() {}, function f3(); + +class C { + m1(), m1(); + m2(), m2() {} + m3() {}, m3(); +} + + +//// [overloadConsecutiveness.js] +// Making sure compiler won't break with declarations that are consecutive in the AST but not consecutive in the source. Syntax errors intentional. +function f2() { } +function f3() { } +var C = (function () { + function C() { + } + C.prototype.m1 = ; + C.prototype.m2 = ; + C.prototype.m2 = function () { }; + C.prototype.m3 = function () { }; + return C; +})(); diff --git a/tests/cases/compiler/overloadConsecutiveness.ts b/tests/cases/compiler/overloadConsecutiveness.ts new file mode 100644 index 00000000000..ced6d88b80c --- /dev/null +++ b/tests/cases/compiler/overloadConsecutiveness.ts @@ -0,0 +1,11 @@ +// Making sure compiler won't break with declarations that are consecutive in the AST but not consecutive in the source. Syntax errors intentional. + +function f1(), function f1(); +function f2(), function f2() {} +function f3() {}, function f3(); + +class C { + m1(), m1(); + m2(), m2() {} + m3() {}, m3(); +} From b31ac2e946ed661ac9e0ea0cf7a2ef43cfa30ac6 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Nov 2015 16:56:20 -0800 Subject: [PATCH 05/51] Add a handful of tests --- .../es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts | 3 +++ .../moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts | 3 +++ .../es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts | 3 +++ .../es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts | 3 +++ 4 files changed, 12 insertions(+) create mode 100644 tests/cases/conformance/es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts create mode 100644 tests/cases/conformance/es6/moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts create mode 100644 tests/cases/conformance/es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts create mode 100644 tests/cases/conformance/es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts diff --git a/tests/cases/conformance/es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts b/tests/cases/conformance/es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts new file mode 100644 index 00000000000..ef0f2ffde17 --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @module: amd +export default class Foo {} diff --git a/tests/cases/conformance/es6/moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts b/tests/cases/conformance/es6/moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts new file mode 100644 index 00000000000..994f24df658 --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @module: commonjs +export default class Foo {} diff --git a/tests/cases/conformance/es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts b/tests/cases/conformance/es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts new file mode 100644 index 00000000000..3764f2ec36c --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @module: system +export default class Foo {} diff --git a/tests/cases/conformance/es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts b/tests/cases/conformance/es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts new file mode 100644 index 00000000000..39784fc7188 --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @module: umd +export default class Foo {} From 57162e9b59c8126e4efc420f52b9666315086048 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Nov 2015 18:11:07 -0800 Subject: [PATCH 06/51] handful more tests --- .../decoratedDefaultExportsGetExportedAmd.ts | 7 +++++++ .../decoratedDefaultExportsGetExportedCommonjs.ts | 7 +++++++ .../decoratedDefaultExportsGetExportedSystem.ts | 7 +++++++ .../decoratedDefaultExportsGetExportedUmd.ts | 7 +++++++ 4 files changed, 28 insertions(+) create mode 100644 tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts create mode 100644 tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts create mode 100644 tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts create mode 100644 tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts diff --git a/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts b/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts new file mode 100644 index 00000000000..3b51b80619f --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @module: amd + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} diff --git a/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts b/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts new file mode 100644 index 00000000000..3fc09a2eeb4 --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @module: commonjs + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} diff --git a/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts b/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts new file mode 100644 index 00000000000..7957b78c805 --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @module: system + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} diff --git a/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts b/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts new file mode 100644 index 00000000000..9dc63bec9c3 --- /dev/null +++ b/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @module: umd + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} From b5ac1eb0ae3bd240b297750ea32b6d5a2e9451c5 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Nov 2015 18:24:04 -0800 Subject: [PATCH 07/51] add decorator flag to tests --- .../moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts | 1 + .../decoratedDefaultExportsGetExportedCommonjs.ts | 1 + .../decoratedDefaultExportsGetExportedSystem.ts | 1 + .../moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts | 1 + 4 files changed, 4 insertions(+) diff --git a/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts b/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts index 3b51b80619f..87fc8afd263 100644 --- a/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts +++ b/tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts @@ -1,4 +1,5 @@ // @target: ES6 +// @experimentalDecorators: true // @module: amd var decorator: ClassDecorator; diff --git a/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts b/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts index 3fc09a2eeb4..aefd07ffdb9 100644 --- a/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts +++ b/tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts @@ -1,4 +1,5 @@ // @target: ES6 +// @experimentalDecorators: true // @module: commonjs var decorator: ClassDecorator; diff --git a/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts b/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts index 7957b78c805..b871b3c7b35 100644 --- a/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts +++ b/tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts @@ -1,4 +1,5 @@ // @target: ES6 +// @experimentalDecorators: true // @module: system var decorator: ClassDecorator; diff --git a/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts b/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts index 9dc63bec9c3..9b0a7d773ef 100644 --- a/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts +++ b/tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts @@ -1,4 +1,5 @@ // @target: ES6 +// @experimentalDecorators: true // @module: umd var decorator: ClassDecorator; From e79253a07c2b913810d5042ed592c3cacaad2f69 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Nov 2015 18:27:47 -0800 Subject: [PATCH 08/51] fix handling of decorated default exports on es6 with nones6 modules --- src/compiler/emitter.ts | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 84d6f091039..ab9fe35b92f 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -5576,9 +5576,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitDecoratorsOfClass(node); } + if (!(node.flags & NodeFlags.Export)) { + return; + } // If this is an exported class, but not on the top level (i.e. on an internal // module), export it - if (!isES6ExportedDeclaration(node) && (node.flags & NodeFlags.Export)) { + if (node.parent.kind !== SyntaxKind.SourceFile) { writeLine(); emitStart(node); emitModuleMemberName(node); @@ -5587,12 +5590,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitEnd(node); write(";"); } - else if (isES6ExportedDeclaration(node) && (node.flags & NodeFlags.Default) && thisNodeIsDecorated) { + else if (node.parent.kind === SyntaxKind.SourceFile && (node.flags & NodeFlags.Default) && thisNodeIsDecorated) { // if this is a top level default export of decorated class, write the export after the declaration. - writeLine(); - write("export default "); - emitDeclarationName(node); - write(";"); + if (modulekind === ModuleKind.ES6) { + writeLine(); + write("export default "); + emitDeclarationName(node); + write(";"); + } + else if (modulekind === ModuleKind.System) { + writeLine(); + write(`${exportFunctionForFile}("default", `); + emitDeclarationName(node); + write(");"); + } + else { + writeLine(); + if (languageVersion === ScriptTarget.ES3) { + write(`exports["default"] = `); + } + else { + write(`exports.default = `); + } + emitDeclarationName(node); + write(";"); + } } } From 521a0a160c36eba85875817efb274c94dac58b87 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Nov 2015 19:03:52 -0800 Subject: [PATCH 09/51] Fix class exports with varrying module emits while targeting es6 --- src/compiler/emitter.ts | 47 ++++++++++++++++++----------------------- 1 file changed, 20 insertions(+), 27 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index ab9fe35b92f..323a5680ccc 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -5581,7 +5581,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } // If this is an exported class, but not on the top level (i.e. on an internal // module), export it - if (node.parent.kind !== SyntaxKind.SourceFile) { + if (node.parent.kind === SyntaxKind.SourceFile && (node.flags & NodeFlags.Default)) { + // if this is a top level default export of decorated class, write the export after the declaration. + writeLine(); + if (thisNodeIsDecorated && modulekind === ModuleKind.ES6) { + write("export default "); + emitDeclarationName(node); + write(";"); + } + else if (modulekind === ModuleKind.System) { + write(`${exportFunctionForFile}("default", `); + emitDeclarationName(node); + write(");"); + } + else if (modulekind !== ModuleKind.ES6) { + write(`exports.default = `); + emitDeclarationName(node); + write(";"); + } + } + else if (node.parent.kind !== SyntaxKind.SourceFile || (modulekind !== ModuleKind.ES6 && !(node.flags & NodeFlags.Default))) { writeLine(); emitStart(node); emitModuleMemberName(node); @@ -5590,32 +5609,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitEnd(node); write(";"); } - else if (node.parent.kind === SyntaxKind.SourceFile && (node.flags & NodeFlags.Default) && thisNodeIsDecorated) { - // if this is a top level default export of decorated class, write the export after the declaration. - if (modulekind === ModuleKind.ES6) { - writeLine(); - write("export default "); - emitDeclarationName(node); - write(";"); - } - else if (modulekind === ModuleKind.System) { - writeLine(); - write(`${exportFunctionForFile}("default", `); - emitDeclarationName(node); - write(");"); - } - else { - writeLine(); - if (languageVersion === ScriptTarget.ES3) { - write(`exports["default"] = `); - } - else { - write(`exports.default = `); - } - emitDeclarationName(node); - write(";"); - } - } } function emitClassLikeDeclarationBelowES6(node: ClassLikeDeclaration) { From 36607b99b51a2d812ca96da24069756acce44375 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Nov 2015 19:05:28 -0800 Subject: [PATCH 10/51] accept baselines for new tests --- .../decoratedDefaultExportsGetExportedAmd.js | 24 ++++++++++++++ ...oratedDefaultExportsGetExportedAmd.symbols | 12 +++++++ ...ecoratedDefaultExportsGetExportedAmd.types | 12 +++++++ ...oratedDefaultExportsGetExportedCommonjs.js | 22 +++++++++++++ ...dDefaultExportsGetExportedCommonjs.symbols | 12 +++++++ ...tedDefaultExportsGetExportedCommonjs.types | 12 +++++++ ...ecoratedDefaultExportsGetExportedSystem.js | 29 +++++++++++++++++ ...tedDefaultExportsGetExportedSystem.symbols | 12 +++++++ ...ratedDefaultExportsGetExportedSystem.types | 12 +++++++ .../decoratedDefaultExportsGetExportedUmd.js | 31 +++++++++++++++++++ ...oratedDefaultExportsGetExportedUmd.symbols | 12 +++++++ ...ecoratedDefaultExportsGetExportedUmd.types | 12 +++++++ .../reference/defaultExportsGetExportedAmd.js | 10 ++++++ .../defaultExportsGetExportedAmd.symbols | 4 +++ .../defaultExportsGetExportedAmd.types | 4 +++ .../defaultExportsGetExportedCommonjs.js | 8 +++++ .../defaultExportsGetExportedCommonjs.symbols | 4 +++ .../defaultExportsGetExportedCommonjs.types | 4 +++ .../defaultExportsGetExportedSystem.js | 16 ++++++++++ .../defaultExportsGetExportedSystem.symbols | 4 +++ .../defaultExportsGetExportedSystem.types | 4 +++ .../reference/defaultExportsGetExportedUmd.js | 17 ++++++++++ .../defaultExportsGetExportedUmd.symbols | 4 +++ .../defaultExportsGetExportedUmd.types | 4 +++ 24 files changed, 285 insertions(+) create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.types create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.types create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.types create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols create mode 100644 tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.types create mode 100644 tests/baselines/reference/defaultExportsGetExportedAmd.js create mode 100644 tests/baselines/reference/defaultExportsGetExportedAmd.symbols create mode 100644 tests/baselines/reference/defaultExportsGetExportedAmd.types create mode 100644 tests/baselines/reference/defaultExportsGetExportedCommonjs.js create mode 100644 tests/baselines/reference/defaultExportsGetExportedCommonjs.symbols create mode 100644 tests/baselines/reference/defaultExportsGetExportedCommonjs.types create mode 100644 tests/baselines/reference/defaultExportsGetExportedSystem.js create mode 100644 tests/baselines/reference/defaultExportsGetExportedSystem.symbols create mode 100644 tests/baselines/reference/defaultExportsGetExportedSystem.types create mode 100644 tests/baselines/reference/defaultExportsGetExportedUmd.js create mode 100644 tests/baselines/reference/defaultExportsGetExportedUmd.symbols create mode 100644 tests/baselines/reference/defaultExportsGetExportedUmd.types diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js new file mode 100644 index 00000000000..441d8b0d70a --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js @@ -0,0 +1,24 @@ +//// [decoratedDefaultExportsGetExportedAmd.ts] + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} + + +//// [decoratedDefaultExportsGetExportedAmd.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +define(["require", "exports"], function (require, exports) { + var decorator; + let Foo = class { + }; + Foo = __decorate([ + decorator + ], Foo); + exports.default = Foo; +}); diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols new file mode 100644 index 00000000000..d8ff6716c38 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts === + +var decorator: ClassDecorator; +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedAmd.ts, 1, 3)) +>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) + +@decorator +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedAmd.ts, 1, 3)) + +export default class Foo {} +>Foo : Symbol(Foo, Decl(decoratedDefaultExportsGetExportedAmd.ts, 1, 30)) + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.types b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.types new file mode 100644 index 00000000000..89df83ce76d --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsAmd/decoratedDefaultExportsGetExportedAmd.ts === + +var decorator: ClassDecorator; +>decorator : (target: TFunction) => TFunction | void +>ClassDecorator : (target: TFunction) => TFunction | void + +@decorator +>decorator : (target: TFunction) => TFunction | void + +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js new file mode 100644 index 00000000000..8818241c9b5 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js @@ -0,0 +1,22 @@ +//// [decoratedDefaultExportsGetExportedCommonjs.ts] + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} + + +//// [decoratedDefaultExportsGetExportedCommonjs.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var decorator; +let Foo = class { +}; +Foo = __decorate([ + decorator +], Foo); +exports.default = Foo; diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols new file mode 100644 index 00000000000..35131c1244e --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts === + +var decorator: ClassDecorator; +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedCommonjs.ts, 1, 3)) +>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) + +@decorator +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedCommonjs.ts, 1, 3)) + +export default class Foo {} +>Foo : Symbol(Foo, Decl(decoratedDefaultExportsGetExportedCommonjs.ts, 1, 30)) + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.types b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.types new file mode 100644 index 00000000000..56c8926342a --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsCommonjs/decoratedDefaultExportsGetExportedCommonjs.ts === + +var decorator: ClassDecorator; +>decorator : (target: TFunction) => TFunction | void +>ClassDecorator : (target: TFunction) => TFunction | void + +@decorator +>decorator : (target: TFunction) => TFunction | void + +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js new file mode 100644 index 00000000000..1ae54560ae3 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js @@ -0,0 +1,29 @@ +//// [decoratedDefaultExportsGetExportedSystem.ts] + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} + + +//// [decoratedDefaultExportsGetExportedSystem.js] +System.register([], function(exports_1) { + var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + }; + var decorator, Foo; + return { + setters:[], + execute: function() { + let Foo = class { + }; + Foo = __decorate([ + decorator + ], Foo); + exports_1("default", Foo); + } + } +}); diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols new file mode 100644 index 00000000000..106ea3cacd8 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts === + +var decorator: ClassDecorator; +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedSystem.ts, 1, 3)) +>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) + +@decorator +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedSystem.ts, 1, 3)) + +export default class Foo {} +>Foo : Symbol(Foo, Decl(decoratedDefaultExportsGetExportedSystem.ts, 1, 30)) + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.types b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.types new file mode 100644 index 00000000000..c180f5fcf09 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsSystem/decoratedDefaultExportsGetExportedSystem.ts === + +var decorator: ClassDecorator; +>decorator : (target: TFunction) => TFunction | void +>ClassDecorator : (target: TFunction) => TFunction | void + +@decorator +>decorator : (target: TFunction) => TFunction | void + +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js new file mode 100644 index 00000000000..118af702fc1 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js @@ -0,0 +1,31 @@ +//// [decoratedDefaultExportsGetExportedUmd.ts] + +var decorator: ClassDecorator; + +@decorator +export default class Foo {} + + +//// [decoratedDefaultExportsGetExportedUmd.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +(function (factory) { + if (typeof module === 'object' && typeof module.exports === 'object') { + var v = factory(require, exports); if (v !== undefined) module.exports = v; + } + else if (typeof define === 'function' && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + var decorator; + let Foo = class { + }; + Foo = __decorate([ + decorator + ], Foo); + exports.default = Foo; +}); diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols new file mode 100644 index 00000000000..f4a8266cfa1 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts === + +var decorator: ClassDecorator; +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedUmd.ts, 1, 3)) +>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) + +@decorator +>decorator : Symbol(decorator, Decl(decoratedDefaultExportsGetExportedUmd.ts, 1, 3)) + +export default class Foo {} +>Foo : Symbol(Foo, Decl(decoratedDefaultExportsGetExportedUmd.ts, 1, 30)) + diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.types b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.types new file mode 100644 index 00000000000..a258a600ba0 --- /dev/null +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/moduleExportsUmd/decoratedDefaultExportsGetExportedUmd.ts === + +var decorator: ClassDecorator; +>decorator : (target: TFunction) => TFunction | void +>ClassDecorator : (target: TFunction) => TFunction | void + +@decorator +>decorator : (target: TFunction) => TFunction | void + +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/defaultExportsGetExportedAmd.js b/tests/baselines/reference/defaultExportsGetExportedAmd.js new file mode 100644 index 00000000000..4eba3ba9600 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedAmd.js @@ -0,0 +1,10 @@ +//// [defaultExportsGetExportedAmd.ts] +export default class Foo {} + + +//// [defaultExportsGetExportedAmd.js] +define(["require", "exports"], function (require, exports) { + class Foo { + } + exports.default = Foo; +}); diff --git a/tests/baselines/reference/defaultExportsGetExportedAmd.symbols b/tests/baselines/reference/defaultExportsGetExportedAmd.symbols new file mode 100644 index 00000000000..22376f91b08 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedAmd.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts === +export default class Foo {} +>Foo : Symbol(Foo, Decl(defaultExportsGetExportedAmd.ts, 0, 0)) + diff --git a/tests/baselines/reference/defaultExportsGetExportedAmd.types b/tests/baselines/reference/defaultExportsGetExportedAmd.types new file mode 100644 index 00000000000..94e511dbef6 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedAmd.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsAmd/defaultExportsGetExportedAmd.ts === +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/defaultExportsGetExportedCommonjs.js b/tests/baselines/reference/defaultExportsGetExportedCommonjs.js new file mode 100644 index 00000000000..a19b99fe9d3 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedCommonjs.js @@ -0,0 +1,8 @@ +//// [defaultExportsGetExportedCommonjs.ts] +export default class Foo {} + + +//// [defaultExportsGetExportedCommonjs.js] +class Foo { +} +exports.default = Foo; diff --git a/tests/baselines/reference/defaultExportsGetExportedCommonjs.symbols b/tests/baselines/reference/defaultExportsGetExportedCommonjs.symbols new file mode 100644 index 00000000000..a5be95f1787 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedCommonjs.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts === +export default class Foo {} +>Foo : Symbol(Foo, Decl(defaultExportsGetExportedCommonjs.ts, 0, 0)) + diff --git a/tests/baselines/reference/defaultExportsGetExportedCommonjs.types b/tests/baselines/reference/defaultExportsGetExportedCommonjs.types new file mode 100644 index 00000000000..d7034ffa03d --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedCommonjs.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsCommonjs/defaultExportsGetExportedCommonjs.ts === +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/defaultExportsGetExportedSystem.js b/tests/baselines/reference/defaultExportsGetExportedSystem.js new file mode 100644 index 00000000000..1f1a7c9dea6 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedSystem.js @@ -0,0 +1,16 @@ +//// [defaultExportsGetExportedSystem.ts] +export default class Foo {} + + +//// [defaultExportsGetExportedSystem.js] +System.register([], function(exports_1) { + var Foo; + return { + setters:[], + execute: function() { + class Foo { + } + exports_1("default", Foo); + } + } +}); diff --git a/tests/baselines/reference/defaultExportsGetExportedSystem.symbols b/tests/baselines/reference/defaultExportsGetExportedSystem.symbols new file mode 100644 index 00000000000..9050833680e --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedSystem.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts === +export default class Foo {} +>Foo : Symbol(Foo, Decl(defaultExportsGetExportedSystem.ts, 0, 0)) + diff --git a/tests/baselines/reference/defaultExportsGetExportedSystem.types b/tests/baselines/reference/defaultExportsGetExportedSystem.types new file mode 100644 index 00000000000..d1439f0f99d --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedSystem.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsSystem/defaultExportsGetExportedSystem.ts === +export default class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/defaultExportsGetExportedUmd.js b/tests/baselines/reference/defaultExportsGetExportedUmd.js new file mode 100644 index 00000000000..ed3639ace55 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedUmd.js @@ -0,0 +1,17 @@ +//// [defaultExportsGetExportedUmd.ts] +export default class Foo {} + + +//// [defaultExportsGetExportedUmd.js] +(function (factory) { + if (typeof module === 'object' && typeof module.exports === 'object') { + var v = factory(require, exports); if (v !== undefined) module.exports = v; + } + else if (typeof define === 'function' && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + class Foo { + } + exports.default = Foo; +}); diff --git a/tests/baselines/reference/defaultExportsGetExportedUmd.symbols b/tests/baselines/reference/defaultExportsGetExportedUmd.symbols new file mode 100644 index 00000000000..9c59f10e6e0 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedUmd.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts === +export default class Foo {} +>Foo : Symbol(Foo, Decl(defaultExportsGetExportedUmd.ts, 0, 0)) + diff --git a/tests/baselines/reference/defaultExportsGetExportedUmd.types b/tests/baselines/reference/defaultExportsGetExportedUmd.types new file mode 100644 index 00000000000..ed5f4b7f709 --- /dev/null +++ b/tests/baselines/reference/defaultExportsGetExportedUmd.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/moduleExportsUmd/defaultExportsGetExportedUmd.ts === +export default class Foo {} +>Foo : Foo + From 732fff225bd988fdaa3c6b420bfdd12041141f4f Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 13 Nov 2015 14:12:11 -0800 Subject: [PATCH 11/51] use common source directory for module paths --- src/compiler/utilities.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index ed7242a785e..1fffaf79332 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1867,7 +1867,7 @@ namespace ts { * Resolves a local path to a path which is absolute to the base of the emit */ export function getExternalModuleNameFromPath(host: EmitHost, fileName: string): string { - const dir = host.getCurrentDirectory(); + const dir = host.getCommonSourceDirectory(); const relativePath = getRelativePathToDirectoryOrUrl(dir, fileName, dir, f => host.getCanonicalFileName(f), /*isAbsolutePathAnUrl*/ false); return removeFileExtension(relativePath); } From 7e69f014f37c9c9d807ba492baf85f26fcabbe5d Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 13 Nov 2015 14:41:09 -0800 Subject: [PATCH 12/51] Always compute a common source directory for a program --- src/compiler/program.ts | 19 ++++++++----------- src/compiler/utilities.ts | 2 +- 2 files changed, 9 insertions(+), 12 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index ca0c7d9adaa..7074dbd45c1 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -329,7 +329,6 @@ namespace ts { let fileProcessingDiagnostics = createDiagnosticCollection(); const programDiagnostics = createDiagnosticCollection(); - let commonSourceDirectory: string; let diagnosticsProducingTypeChecker: TypeChecker; let noDiagnosticsTypeChecker: TypeChecker; let classifiableNames: Map; @@ -374,6 +373,8 @@ namespace ts { } } + // _Always_ compute a common source directory + let commonSourceDirectory = computeCommonSourceDirectory(files); verifyCompilerOptions(); // unconditionally set oldProgram to undefined to prevent it from being captured in closure @@ -1056,17 +1057,13 @@ namespace ts { // If a rootDir is specified and is valid use it as the commonSourceDirectory commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory); } - else { - // Compute the commonSourceDirectory from the input files - commonSourceDirectory = computeCommonSourceDirectory(files); - } + } - if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) { - // Make sure directory path ends with directory separator so this string can directly - // used to replace with "" to get the relative path of the source file and the relative path doesn't - // start with / making it rooted path - commonSourceDirectory += directorySeparator; - } + if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) { + // Make sure directory path ends with directory separator so this string can directly + // used to replace with "" to get the relative path of the source file and the relative path doesn't + // start with / making it rooted path + commonSourceDirectory += directorySeparator; } if (options.noEmit) { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 1fffaf79332..dc5d9db30bc 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1867,7 +1867,7 @@ namespace ts { * Resolves a local path to a path which is absolute to the base of the emit */ export function getExternalModuleNameFromPath(host: EmitHost, fileName: string): string { - const dir = host.getCommonSourceDirectory(); + const dir = toPath(host.getCommonSourceDirectory(), host.getCurrentDirectory(), f => host.getCanonicalFileName(f)); const relativePath = getRelativePathToDirectoryOrUrl(dir, fileName, dir, f => host.getCanonicalFileName(f), /*isAbsolutePathAnUrl*/ false); return removeFileExtension(relativePath); } From 5b29a7e9d9d0d2c82cf980b2c4a4befaa7010ea8 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 13 Nov 2015 14:41:49 -0800 Subject: [PATCH 13/51] accept corrected projects baselines --- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 ------------------- .../amd/bin/test.js | 6 ++-- ...MultifolderSpecifyOutputFile.sourcemap.txt | 6 ++-- .../node/bin/test.d.ts | 4 +-- 35 files changed, 69 insertions(+), 321 deletions(-) delete mode 100644 tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts delete mode 100644 tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 25cd156c4ab..e76de4f44f7 100644 --- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt index 4462b142d98..a6e6ece1e9e 100644 --- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: ../ref/m1.ts,../../outputdir_module_multifolder_ref/m2.ts,../test.ts emittedFile:bin/test.js sourceFile:../ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:../../outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:../test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 8b109433561..bd620fe66b8 100644 --- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt index 47e1835365a..98e1a2211cb 100644 --- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: ../projects/outputdir_module_multifolder/ref/m1.ts,../projects/outputdi emittedFile:bin/test.js sourceFile:../projects/outputdir_module_multifolder/ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:../projects/outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:../projects/outputdir_module_multifolder/test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 0734d350e11..0b83e26b91f 100644 --- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt index 5805c876be8..1a2de1cd877 100644 --- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: file:///tests/cases/projects/outputdir_module_multifolder/ref/m1.ts,fil emittedFile:bin/test.js sourceFile:file:///tests/cases/projects/outputdir_module_multifolder/ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:file:///tests/cases/projects/outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:file:///tests/cases/projects/outputdir_module_multifolder/test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 0734d350e11..0b83e26b91f 100644 --- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt index 20a97890399..e9f5746232c 100644 --- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: outputdir_module_multifolder/ref/m1.ts,outputdir_module_multifolder_ref emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 0814424ca39..be6fc113146 100644 --- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 994e21ca032..052e4455dba 100644 --- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt index 8c710d9c4da..631f29953c1 100644 --- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: outputdir_module_multifolder/ref/m1.ts,outputdir_module_multifolder_ref emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 994e21ca032..052e4455dba 100644 --- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt index 43c4340ba37..2499da34f4f 100644 --- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: outputdir_module_multifolder/ref/m1.ts,outputdir_module_multifolder_ref emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 994e21ca032..052e4455dba 100644 --- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.sourcemap.txt index 6c8bdf4da74..8ea4710f7ff 100644 --- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: ../ref/m1.ts,../../outputdir_module_multifolder_ref/m2.ts,../test.ts emittedFile:bin/test.js sourceFile:../ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:../../outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:../test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts deleted file mode 100644 index 9b6af66589a..00000000000 --- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts +++ /dev/null @@ -1,28 +0,0 @@ -declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; -} -declare module "../outputdir_module_multifolder_ref/m2" { - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; -} -declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; -} diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js index 994e21ca032..052e4455dba 100644 --- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js +++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js @@ -1,4 +1,4 @@ -define("ref/m1", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { exports.m1_a1 = 10; var m1_c1 = (function () { function m1_c1() { @@ -12,7 +12,7 @@ define("ref/m1", ["require", "exports"], function (require, exports) { } exports.m1_f1 = m1_f1; }); -define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { exports.m2_a1 = 10; var m2_c1 = (function () { function m2_c1() { @@ -26,7 +26,7 @@ define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], functio } exports.m2_f1 = m2_f1; }); -define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { exports.a1 = 10; var c1 = (function () { function c1() { diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt index d2331ef3579..36c3893e3a4 100644 --- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt +++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.sourcemap.txt @@ -8,7 +8,7 @@ sources: outputdir_module_multifolder/ref/m1.ts,outputdir_module_multifolder_ref emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/ref/m1.ts ------------------------------------------------------------------- ->>>define("ref/m1", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder/ref/m1", ["require", "exports"], function (require, exports) { >>> exports.m1_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -174,7 +174,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder_ref/m2.ts ------------------------------------------------------------------- >>>}); ->>>define("../outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { +>>>define("outputdir_module_multifolder_ref/m2", ["require", "exports"], function (require, exports) { >>> exports.m2_a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^^^^ @@ -340,7 +340,7 @@ emittedFile:bin/test.js sourceFile:outputdir_module_multifolder/test.ts ------------------------------------------------------------------- >>>}); ->>>define("test", ["require", "exports", "ref/m1", "../outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { +>>>define("test", ["require", "exports", "outputdir_module_multifolder/ref/m1", "outputdir_module_multifolder_ref/m2"], function (require, exports, m1, m2) { >>> exports.a1 = 10; 1 >^^^^ 2 > ^^^^^^^^^^ diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index 9b6af66589a..b4be78a74af 100644 --- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -1,4 +1,4 @@ -declare module "ref/m1" { +declare module "outputdir_module_multifolder/ref/m1" { export var m1_a1: number; export class m1_c1 { m1_c1_p1: number; @@ -6,7 +6,7 @@ declare module "ref/m1" { export var m1_instance1: m1_c1; export function m1_f1(): m1_c1; } -declare module "../outputdir_module_multifolder_ref/m2" { +declare module "outputdir_module_multifolder_ref/m2" { export var m2_a1: number; export class m2_c1 { m2_c1_p1: number; From cb1724bd44a0f1e8b9200547297bc1837a35f8bf Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 13 Nov 2015 15:26:38 -0800 Subject: [PATCH 14/51] in declaration emit, handle = require (again) --- src/compiler/declarationEmitter.ts | 2 +- src/compiler/emitter.ts | 25 +++++++++---------------- 2 files changed, 10 insertions(+), 17 deletions(-) diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 669cbcbcf0c..b531302d01b 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -680,7 +680,7 @@ namespace ts { } else { write("require("); - writeTextOfNode(currentText, getExternalModuleImportEqualsDeclarationExpression(node)); + emitExternalModuleSpecifier(getExternalModuleImportEqualsDeclarationExpression(node)); write(");"); } writer.writeLine(); diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 2ea8c81c7e2..a483fe29cff 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -6804,7 +6804,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } - function getExternalModuleNameText(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration): string { + function getExternalModuleNameText(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration, emitRelativePathAsModuleName: boolean): string { + if (emitRelativePathAsModuleName) { + const name = getExternalModuleNameFromDeclaration(host, resolver, importNode); + if (name) { + return `"${name}"`; + } + } const moduleName = getExternalModuleName(importNode); if (moduleName.kind === SyntaxKind.StringLiteral) { return tryRenameExternalModule(moduleName) || getLiteralText(moduleName); @@ -7364,7 +7370,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi const dependencyGroups: DependencyGroup[] = []; for (let i = 0; i < externalImports.length; ++i) { - let text = getExternalModuleNameText(externalImports[i]); + const text = getExternalModuleNameText(externalImports[i], emitRelativePathAsModuleName); if (hasProperty(groupIndices, text)) { // deduplicate/group entries in dependency list by the dependency name const groupIndex = groupIndices[text]; @@ -7380,12 +7386,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(", "); } - if (emitRelativePathAsModuleName) { - const name = getExternalModuleNameFromDeclaration(host, resolver, externalImports[i]); - if (name) { - text = `"${name}"`; - } - } write(text); } write(`], function(${exportFunctionForFile}) {`); @@ -7428,14 +7428,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi for (const importNode of externalImports) { // Find the name of the external module - let externalModuleName = getExternalModuleNameText(importNode); - - if (emitRelativePathAsModuleName) { - const name = getExternalModuleNameFromDeclaration(host, resolver, importNode); - if (name) { - externalModuleName = `"${name}"`; - } - } + const externalModuleName = getExternalModuleNameText(importNode, emitRelativePathAsModuleName); // Find the name of the module alias, if there is one const importAliasName = getLocalNameForExternalImport(importNode); From 78e7804668a6d6f442eca0b113deb30695a8fef8 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 13 Nov 2015 15:46:48 -0800 Subject: [PATCH 15/51] handle things more rightly --- src/compiler/declarationEmitter.ts | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index b531302d01b..79bee2a3b75 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -680,7 +680,7 @@ namespace ts { } else { write("require("); - emitExternalModuleSpecifier(getExternalModuleImportEqualsDeclarationExpression(node)); + emitExternalModuleSpecifier(node); write(");"); } writer.writeLine(); @@ -737,14 +737,23 @@ namespace ts { } write(" from "); } - emitExternalModuleSpecifier(node.moduleSpecifier); + emitExternalModuleSpecifier(node); write(";"); writer.writeLine(); } - function emitExternalModuleSpecifier(moduleSpecifier: Expression) { + function emitExternalModuleSpecifier(parent: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration) { + let moduleSpecifier: Node; + if (parent.kind === SyntaxKind.ImportEqualsDeclaration) { + const node = parent as ImportEqualsDeclaration; + moduleSpecifier = getExternalModuleImportEqualsDeclarationExpression(node); + } + else { + const node = parent as (ImportDeclaration | ExportDeclaration); + moduleSpecifier = node.moduleSpecifier; + } if (moduleSpecifier.kind === SyntaxKind.StringLiteral && (!root) && (compilerOptions.out || compilerOptions.outFile)) { - const moduleName = getExternalModuleNameFromDeclaration(host, resolver, moduleSpecifier.parent as (ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration)); + const moduleName = getExternalModuleNameFromDeclaration(host, resolver, parent); if (moduleName) { write("\""); write(moduleName); @@ -787,7 +796,7 @@ namespace ts { } if (node.moduleSpecifier) { write(" from "); - emitExternalModuleSpecifier(node.moduleSpecifier); + emitExternalModuleSpecifier(node); } write(";"); writer.writeLine(); From 13faf2ccf415963b0d86c42f7a55c9a44a160039 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 13 Nov 2015 15:47:19 -0800 Subject: [PATCH 16/51] get projects dts back --- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../node/bin/test.d.ts | 4 +-- 18 files changed, 270 insertions(+), 18 deletions(-) create mode 100644 tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts index b4be78a74af..d42fc1cd136 100644 --- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts +++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts @@ -15,8 +15,8 @@ declare module "outputdir_module_multifolder_ref/m2" { export function m2_f1(): m2_c1; } declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); export var a1: number; export class c1 { p1: number; From e41f1ae04d69f1dadf02c40c56d378098865f2ff Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 17 Nov 2015 13:03:15 -0800 Subject: [PATCH 17/51] only check against default flag --- src/compiler/emitter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 4bddaa221e8..1cd017cbf2b 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -5583,7 +5583,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } // If this is an exported class, but not on the top level (i.e. on an internal // module), export it - if (node.parent.kind === SyntaxKind.SourceFile && (node.flags & NodeFlags.Default)) { + if (node.flags & NodeFlags.Default) { // if this is a top level default export of decorated class, write the export after the declaration. writeLine(); if (thisNodeIsDecorated && modulekind === ModuleKind.ES6) { From a44ebbbc7eec05931e26b1646630929bba942e58 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 18 Nov 2015 13:19:56 -0800 Subject: [PATCH 18/51] only make common dir on call --- src/compiler/program.ts | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index d3eb24b7540..bd59410b738 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -374,7 +374,7 @@ namespace ts { } // _Always_ compute a common source directory - let commonSourceDirectory = computeCommonSourceDirectory(files); + let commonSourceDirectory: string; verifyCompilerOptions(); // unconditionally set oldProgram to undefined to prevent it from being captured in closure @@ -395,7 +395,9 @@ namespace ts { getTypeChecker, getClassifiableNames, getDiagnosticsProducingTypeChecker, - getCommonSourceDirectory: () => commonSourceDirectory, + getCommonSourceDirectory: () => { + return typeof commonSourceDirectory === "undefined" ? (commonSourceDirectory = computeCommonSourceDirectory(files)) : commonSourceDirectory; + }, emit, getCurrentDirectory: () => currentDirectory, getNodeCount: () => getDiagnosticsProducingTypeChecker().getNodeCount(), @@ -1071,11 +1073,12 @@ namespace ts { } } - if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) { - // Make sure directory path ends with directory separator so this string can directly - // used to replace with "" to get the relative path of the source file and the relative path doesn't - // start with / making it rooted path - commonSourceDirectory += directorySeparator; + if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) { + // Make sure directory path ends with directory separator so this string can directly + // used to replace with "" to get the relative path of the source file and the relative path doesn't + // start with / making it rooted path + commonSourceDirectory += directorySeparator; + } } if (options.noEmit) { From 294f846d265e4f6120087111027d6277c0f3e11f Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 18 Nov 2015 13:56:38 -0800 Subject: [PATCH 19/51] Add a test which uses common src dir in a different way --- tests/baselines/reference/commonSourceDir5.js | 29 +++++++++++ .../reference/commonSourceDir5.symbols | 42 ++++++++++++++++ .../reference/commonSourceDir5.types | 48 +++++++++++++++++++ tests/cases/compiler/commonSourceDir5.ts | 17 +++++++ 4 files changed, 136 insertions(+) create mode 100644 tests/baselines/reference/commonSourceDir5.js create mode 100644 tests/baselines/reference/commonSourceDir5.symbols create mode 100644 tests/baselines/reference/commonSourceDir5.types create mode 100644 tests/cases/compiler/commonSourceDir5.ts diff --git a/tests/baselines/reference/commonSourceDir5.js b/tests/baselines/reference/commonSourceDir5.js new file mode 100644 index 00000000000..3270df7015f --- /dev/null +++ b/tests/baselines/reference/commonSourceDir5.js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/commonSourceDir5.ts] //// + +//// [bar.ts] +import {z} from "./foo"; +export var x = z + z; + +//// [foo.ts] +import {pi} from "B:/baz"; +export var i = Math.sqrt(-1); +export var z = pi * pi; + +//// [baz.ts] +import {x} from "A:/bar"; +import {i} from "A:/foo"; +export var pi = Math.PI; +export var y = x * i; + +//// [concat.js] +define("B:/baz", ["require", "exports", "A:/bar", "A:/foo"], function (require, exports, bar_1, foo_1) { + exports.pi = Math.PI; + exports.y = bar_1.x * foo_1.i; +}); +define("A:/foo", ["require", "exports", "B:/baz"], function (require, exports, baz_1) { + exports.i = Math.sqrt(-1); + exports.z = baz_1.pi * baz_1.pi; +}); +define("A:/bar", ["require", "exports", "A:/foo"], function (require, exports, foo_2) { + exports.x = foo_2.z + foo_2.z; +}); diff --git a/tests/baselines/reference/commonSourceDir5.symbols b/tests/baselines/reference/commonSourceDir5.symbols new file mode 100644 index 00000000000..6426ac39de3 --- /dev/null +++ b/tests/baselines/reference/commonSourceDir5.symbols @@ -0,0 +1,42 @@ +=== A:/bar.ts === +import {z} from "./foo"; +>z : Symbol(z, Decl(bar.ts, 0, 8)) + +export var x = z + z; +>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"; +>pi : Symbol(pi, Decl(foo.ts, 0, 8)) + +export var i = Math.sqrt(-1); +>i : Symbol(i, Decl(foo.ts, 1, 10)) +>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, --, --)) + +export var z = pi * pi; +>z : Symbol(z, Decl(foo.ts, 2, 10)) +>pi : Symbol(pi, Decl(foo.ts, 0, 8)) +>pi : Symbol(pi, Decl(foo.ts, 0, 8)) + +=== B:/baz.ts === +import {x} from "A:/bar"; +>x : Symbol(x, Decl(baz.ts, 0, 8)) + +import {i} from "A:/foo"; +>i : Symbol(i, Decl(baz.ts, 1, 8)) + +export var pi = Math.PI; +>pi : Symbol(pi, Decl(baz.ts, 2, 10)) +>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, --, --)) + +export var y = x * i; +>y : Symbol(y, Decl(baz.ts, 3, 10)) +>x : Symbol(x, Decl(baz.ts, 0, 8)) +>i : Symbol(i, Decl(baz.ts, 1, 8)) + diff --git a/tests/baselines/reference/commonSourceDir5.types b/tests/baselines/reference/commonSourceDir5.types new file mode 100644 index 00000000000..ff13bb20215 --- /dev/null +++ b/tests/baselines/reference/commonSourceDir5.types @@ -0,0 +1,48 @@ +=== A:/bar.ts === +import {z} from "./foo"; +>z : number + +export var x = z + z; +>x : number +>z + z : number +>z : number +>z : number + +=== A:/foo.ts === +import {pi} from "B:/baz"; +>pi : number + +export var i = Math.sqrt(-1); +>i : number +>Math.sqrt(-1) : number +>Math.sqrt : (x: number) => number +>Math : Math +>sqrt : (x: number) => number +>-1 : number +>1 : number + +export var z = pi * pi; +>z : number +>pi * pi : number +>pi : number +>pi : number + +=== B:/baz.ts === +import {x} from "A:/bar"; +>x : number + +import {i} from "A:/foo"; +>i : number + +export var pi = Math.PI; +>pi : number +>Math.PI : number +>Math : Math +>PI : number + +export var y = x * i; +>y : number +>x * i : number +>x : number +>i : number + diff --git a/tests/cases/compiler/commonSourceDir5.ts b/tests/cases/compiler/commonSourceDir5.ts new file mode 100644 index 00000000000..d181bef68fe --- /dev/null +++ b/tests/cases/compiler/commonSourceDir5.ts @@ -0,0 +1,17 @@ +// @outFile: concat.js +// @module: amd +// @moduleResolution: node +// @Filename: A:/bar.ts +import {z} from "./foo"; +export var x = z + z; + +// @Filename: A:/foo.ts +import {pi} from "B:/baz"; +export var i = Math.sqrt(-1); +export var z = pi * pi; + +// @Filename: B:/baz.ts +import {x} from "A:/bar"; +import {i} from "A:/foo"; +export var pi = Math.PI; +export var y = x * i; \ No newline at end of file From c0f185943c2259cd821d1a607bc78a611c01b968 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 18 Nov 2015 14:10:53 -0800 Subject: [PATCH 20/51] remove comment --- src/compiler/program.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index bd59410b738..d5b2eb1aea4 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -329,6 +329,7 @@ namespace ts { let fileProcessingDiagnostics = createDiagnosticCollection(); const programDiagnostics = createDiagnosticCollection(); + let commonSourceDirectory: string; let diagnosticsProducingTypeChecker: TypeChecker; let noDiagnosticsTypeChecker: TypeChecker; let classifiableNames: Map; @@ -373,8 +374,6 @@ namespace ts { } } - // _Always_ compute a common source directory - let commonSourceDirectory: string; verifyCompilerOptions(); // unconditionally set oldProgram to undefined to prevent it from being captured in closure From 08045dfd3164a8759658b307f42001ccfc815533 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 18 Nov 2015 17:10:22 -0800 Subject: [PATCH 21/51] Refactor getCommonSourceDirectory into a closure function --- src/compiler/program.ts | 45 +++++++++++++++++++++++------------------ 1 file changed, 25 insertions(+), 20 deletions(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index d5b2eb1aea4..3dd9c06ac34 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -394,9 +394,7 @@ namespace ts { getTypeChecker, getClassifiableNames, getDiagnosticsProducingTypeChecker, - getCommonSourceDirectory: () => { - return typeof commonSourceDirectory === "undefined" ? (commonSourceDirectory = computeCommonSourceDirectory(files)) : commonSourceDirectory; - }, + getCommonSourceDirectory, emit, getCurrentDirectory: () => currentDirectory, getNodeCount: () => getDiagnosticsProducingTypeChecker().getNodeCount(), @@ -407,6 +405,25 @@ namespace ts { }; return program; + function getCommonSourceDirectory() { + if (typeof commonSourceDirectory === "undefined") { + if (options.rootDir && checkSourceFilesBelongToPath(files, options.rootDir)) { + // If a rootDir is specified and is valid use it as the commonSourceDirectory + commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory); + } + else { + commonSourceDirectory = computeCommonSourceDirectory(files); + } + if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) { + // Make sure directory path ends with directory separator so this string can directly + // used to replace with "" to get the relative path of the source file and the relative path doesn't + // start with / making it rooted path + commonSourceDirectory += directorySeparator; + } + } + return commonSourceDirectory; + } + function getClassifiableNames() { if (!classifiableNames) { // Initialize a checker so that all our files are bound. @@ -1059,24 +1076,12 @@ namespace ts { options.sourceRoot || // there is --sourceRoot specified options.mapRoot) { // there is --mapRoot specified - if (options.rootDir && checkSourceFilesBelongToPath(files, options.rootDir)) { - // If a rootDir is specified and is valid use it as the commonSourceDirectory - commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory); - } - else { - // Compute the commonSourceDirectory from the input files - commonSourceDirectory = computeCommonSourceDirectory(files); - // If we failed to find a good common directory, but outDir is specified and at least one of our files is on a windows drive/URL/other resource, add a failure - if (options.outDir && commonSourceDirectory === "" && forEach(files, file => getRootLength(file.fileName) > 1)) { - programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files)); - } - } + // Precalculate and cache the common source directory + const dir = getCommonSourceDirectory(); - if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) { - // Make sure directory path ends with directory separator so this string can directly - // used to replace with "" to get the relative path of the source file and the relative path doesn't - // start with / making it rooted path - commonSourceDirectory += directorySeparator; + // If we failed to find a good common directory, but outDir is specified and at least one of our files is on a windows drive/URL/other resource, add a failure + if (options.outDir && dir === "" && forEach(files, file => getRootLength(file.fileName) > 1)) { + programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files)); } } From ba3805d6f27ac0e2964fda866860b78b837306d4 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 18 Nov 2015 17:29:16 -0800 Subject: [PATCH 22/51] add a new test --- tests/cases/compiler/commonSourceDir6.ts | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 tests/cases/compiler/commonSourceDir6.ts diff --git a/tests/cases/compiler/commonSourceDir6.ts b/tests/cases/compiler/commonSourceDir6.ts new file mode 100644 index 00000000000..ff2b1309035 --- /dev/null +++ b/tests/cases/compiler/commonSourceDir6.ts @@ -0,0 +1,17 @@ +// @outFile: concat.js +// @outDir: a +// @module: amd +// @Filename: a/bar.ts +import {z} from "./foo"; +export var x = z + z; + +// @Filename: a/foo.ts +import {pi} from "../baz"; +export var i = Math.sqrt(-1); +export var z = pi * pi; + +// @Filename: baz.ts +import {x} from "a/bar"; +import {i} from "a/foo"; +export var pi = Math.PI; +export var y = x * i; \ No newline at end of file From 075bea0ab86d4e1a987f0f1024911a873904af84 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 19 Nov 2015 12:48:01 -0800 Subject: [PATCH 23/51] I forgot to commit the baselines. T.T --- tests/baselines/reference/commonSourceDir6.js | 29 +++++++++++ .../reference/commonSourceDir6.symbols | 42 ++++++++++++++++ .../reference/commonSourceDir6.types | 48 +++++++++++++++++++ 3 files changed, 119 insertions(+) create mode 100644 tests/baselines/reference/commonSourceDir6.js create mode 100644 tests/baselines/reference/commonSourceDir6.symbols create mode 100644 tests/baselines/reference/commonSourceDir6.types diff --git a/tests/baselines/reference/commonSourceDir6.js b/tests/baselines/reference/commonSourceDir6.js new file mode 100644 index 00000000000..c08c8645006 --- /dev/null +++ b/tests/baselines/reference/commonSourceDir6.js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/commonSourceDir6.ts] //// + +//// [bar.ts] +import {z} from "./foo"; +export var x = z + z; + +//// [foo.ts] +import {pi} from "../baz"; +export var i = Math.sqrt(-1); +export var z = pi * pi; + +//// [baz.ts] +import {x} from "a/bar"; +import {i} from "a/foo"; +export var pi = Math.PI; +export var y = x * i; + +//// [concat.js] +define("tests/cases/compiler/baz", ["require", "exports", "tests/cases/compiler/a/bar", "tests/cases/compiler/a/foo"], function (require, exports, bar_1, foo_1) { + exports.pi = Math.PI; + exports.y = bar_1.x * foo_1.i; +}); +define("tests/cases/compiler/a/foo", ["require", "exports", "tests/cases/compiler/baz"], function (require, exports, baz_1) { + exports.i = Math.sqrt(-1); + exports.z = baz_1.pi * baz_1.pi; +}); +define("tests/cases/compiler/a/bar", ["require", "exports", "tests/cases/compiler/a/foo"], function (require, exports, foo_2) { + exports.x = foo_2.z + foo_2.z; +}); diff --git a/tests/baselines/reference/commonSourceDir6.symbols b/tests/baselines/reference/commonSourceDir6.symbols new file mode 100644 index 00000000000..e9d5edb28b2 --- /dev/null +++ b/tests/baselines/reference/commonSourceDir6.symbols @@ -0,0 +1,42 @@ +=== tests/cases/compiler/a/bar.ts === +import {z} from "./foo"; +>z : Symbol(z, Decl(bar.ts, 0, 8)) + +export var x = z + z; +>x : Symbol(x, Decl(bar.ts, 1, 10)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) + +=== tests/cases/compiler/a/foo.ts === +import {pi} from "../baz"; +>pi : Symbol(pi, Decl(foo.ts, 0, 8)) + +export var i = Math.sqrt(-1); +>i : Symbol(i, Decl(foo.ts, 1, 10)) +>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, --, --)) + +export var z = pi * pi; +>z : Symbol(z, Decl(foo.ts, 2, 10)) +>pi : Symbol(pi, Decl(foo.ts, 0, 8)) +>pi : Symbol(pi, Decl(foo.ts, 0, 8)) + +=== tests/cases/compiler/baz.ts === +import {x} from "a/bar"; +>x : Symbol(x, Decl(baz.ts, 0, 8)) + +import {i} from "a/foo"; +>i : Symbol(i, Decl(baz.ts, 1, 8)) + +export var pi = Math.PI; +>pi : Symbol(pi, Decl(baz.ts, 2, 10)) +>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, --, --)) + +export var y = x * i; +>y : Symbol(y, Decl(baz.ts, 3, 10)) +>x : Symbol(x, Decl(baz.ts, 0, 8)) +>i : Symbol(i, Decl(baz.ts, 1, 8)) + diff --git a/tests/baselines/reference/commonSourceDir6.types b/tests/baselines/reference/commonSourceDir6.types new file mode 100644 index 00000000000..e30cdd2deee --- /dev/null +++ b/tests/baselines/reference/commonSourceDir6.types @@ -0,0 +1,48 @@ +=== tests/cases/compiler/a/bar.ts === +import {z} from "./foo"; +>z : number + +export var x = z + z; +>x : number +>z + z : number +>z : number +>z : number + +=== tests/cases/compiler/a/foo.ts === +import {pi} from "../baz"; +>pi : number + +export var i = Math.sqrt(-1); +>i : number +>Math.sqrt(-1) : number +>Math.sqrt : (x: number) => number +>Math : Math +>sqrt : (x: number) => number +>-1 : number +>1 : number + +export var z = pi * pi; +>z : number +>pi * pi : number +>pi : number +>pi : number + +=== tests/cases/compiler/baz.ts === +import {x} from "a/bar"; +>x : number + +import {i} from "a/foo"; +>i : number + +export var pi = Math.PI; +>pi : number +>Math.PI : number +>Math : Math +>PI : number + +export var y = x * i; +>y : number +>x * i : number +>x : number +>i : number + From f5b8619199535d0ef593abbaff9e909d495499c7 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 19 Nov 2015 17:08:51 -0800 Subject: [PATCH 24/51] Adds StringLiteralType to SyntaxKind to disambiguate string literals in a type position. --- src/compiler/checker.ts | 16 +++++++-------- src/compiler/declarationEmitter.ts | 2 +- src/compiler/emitter.ts | 11 +++++----- src/compiler/parser.ts | 24 ++++++++++++++++------ src/compiler/types.ts | 32 ++++++++++++++++++++---------- src/compiler/utilities.ts | 3 --- src/services/services.ts | 7 +++++-- src/services/utilities.ts | 15 +++++++------- 8 files changed, 67 insertions(+), 43 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8f47b90cfb7..a155387d2ee 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -532,7 +532,7 @@ namespace ts { } // Because of module/namespace merging, a module's exports are in scope, - // yet we never want to treat an export specifier as putting a member in scope. + // yet we never want to treat an export specifier as putting a member in scope. // Therefore, if the name we find is purely an export specifier, it is not actually considered in scope. // Two things to note about this: // 1. We have to check this without calling getSymbol. The problem with calling getSymbol @@ -3201,7 +3201,7 @@ namespace ts { case SyntaxKind.BooleanKeyword: case SyntaxKind.SymbolKeyword: case SyntaxKind.VoidKeyword: - case SyntaxKind.StringLiteral: + case SyntaxKind.StringLiteralType: return true; case SyntaxKind.ArrayType: return isIndependentType((node).elementType); @@ -3862,7 +3862,7 @@ namespace ts { paramSymbol = resolvedSymbol; } parameters.push(paramSymbol); - if (param.type && param.type.kind === SyntaxKind.StringLiteral) { + if (param.type && param.type.kind === SyntaxKind.StringLiteralType) { hasStringLiterals = true; } @@ -4531,7 +4531,7 @@ namespace ts { return links.resolvedType; } - function getStringLiteralType(node: StringLiteral): StringLiteralType { + function getStringLiteralType(node: StringLiteral | StringLiteralTypeNode): StringLiteralType { const text = node.text; if (hasProperty(stringLiteralTypes, text)) { return stringLiteralTypes[text]; @@ -4542,7 +4542,7 @@ namespace ts { return type; } - function getTypeFromStringLiteral(node: StringLiteral): Type { + function getTypeFromStringLiteral(node: StringLiteral | StringLiteralTypeNode): Type { const links = getNodeLinks(node); if (!links.resolvedType) { links.resolvedType = getStringLiteralType(node); @@ -4587,8 +4587,8 @@ namespace ts { return voidType; case SyntaxKind.ThisType: return getTypeFromThisTypeNode(node); - case SyntaxKind.StringLiteral: - return getTypeFromStringLiteral(node); + case SyntaxKind.StringLiteralType: + return getTypeFromStringLiteral(node); case SyntaxKind.TypeReference: return getTypeFromTypeReference(node); case SyntaxKind.TypePredicate: @@ -11397,7 +11397,7 @@ namespace ts { // we can get here in two cases // 1. mixed static and instance class members // 2. something with the same name was defined before the set of overloads that prevents them from merging - // here we'll report error only for the first case since for second we should already report error in binder + // here we'll report error only for the first case since for second we should already report error in binder if (reportError) { const diagnostic = node.flags & NodeFlags.Static ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static; error(errorNode, diagnostic); diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 59f89226d5f..a9bcbd830f0 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -379,7 +379,7 @@ namespace ts { case SyntaxKind.SymbolKeyword: case SyntaxKind.VoidKeyword: case SyntaxKind.ThisType: - case SyntaxKind.StringLiteral: + case SyntaxKind.StringLiteralType: return writeTextOfNode(currentText, type); case SyntaxKind.ExpressionWithTypeArguments: return emitExpressionWithTypeArguments(type); diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 2e07d7a634e..40b37e04191 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1310,7 +1310,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } - function isBinaryOrOctalIntegerLiteral(node: LiteralExpression, text: string): boolean { + function isBinaryOrOctalIntegerLiteral(node: LiteralLikeNode, text: string): boolean { if (node.kind === SyntaxKind.NumericLiteral && text.length > 1) { switch (text.charCodeAt(1)) { case CharacterCodes.b: @@ -1324,7 +1324,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi return false; } - function emitLiteral(node: LiteralExpression) { + function emitLiteral(node: LiteralExpression | TemplateLiteralFragment) { const text = getLiteralText(node); if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap) && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) { @@ -1339,7 +1339,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } - function getLiteralText(node: LiteralExpression) { + function getLiteralText(node: LiteralExpression | TemplateLiteralFragment) { // Any template literal or string literal with an extended escape // (e.g. "\u{0067}") will need to be downleveled as a escaped string literal. if (languageVersion < ScriptTarget.ES6 && (isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) { @@ -1398,7 +1398,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(`"${text}"`); } - function emitDownlevelTaggedTemplateArray(node: TaggedTemplateExpression, literalEmitter: (literal: LiteralExpression) => void) { + function emitDownlevelTaggedTemplateArray(node: TaggedTemplateExpression, literalEmitter: (literal: LiteralExpression | TemplateLiteralFragment) => void) { write("["); if (node.template.kind === SyntaxKind.NoSubstitutionTemplateLiteral) { literalEmitter(node.template); @@ -5964,7 +5964,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function emitSerializedTypeNode(node: TypeNode) { if (node) { - switch (node.kind) { case SyntaxKind.VoidKeyword: write("void 0"); @@ -5990,7 +5989,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi return; case SyntaxKind.StringKeyword: - case SyntaxKind.StringLiteral: + case SyntaxKind.StringLiteralType: write("String"); return; diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 6dbadd074d4..b12db7b0fb1 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1869,7 +1869,7 @@ namespace ts { function parseTemplateExpression(): TemplateExpression { const template = createNode(SyntaxKind.TemplateExpression); - template.head = parseLiteralNode(); + template.head = parseTemplateLiteralFragment(); Debug.assert(template.head.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind"); const templateSpans = >[]; @@ -1890,22 +1890,34 @@ namespace ts { const span = createNode(SyntaxKind.TemplateSpan); span.expression = allowInAnd(parseExpression); - let literal: LiteralExpression; + let literal: TemplateLiteralFragment; if (token === SyntaxKind.CloseBraceToken) { reScanTemplateToken(); - literal = parseLiteralNode(); + literal = parseTemplateLiteralFragment(); } else { - literal = parseExpectedToken(SyntaxKind.TemplateTail, /*reportAtCurrentPosition*/ false, Diagnostics._0_expected, tokenToString(SyntaxKind.CloseBraceToken)); + literal = parseExpectedToken(SyntaxKind.TemplateTail, /*reportAtCurrentPosition*/ false, Diagnostics._0_expected, tokenToString(SyntaxKind.CloseBraceToken)); } span.literal = literal; return finishNode(span); } + function parseStringLiteralTypeNode(): StringLiteralTypeNode { + return parseLiteralLikeNode(SyntaxKind.StringLiteralType, /*internName*/ true); + } + function parseLiteralNode(internName?: boolean): LiteralExpression { - const node = createNode(token); + return parseLiteralLikeNode(token, internName); + } + + function parseTemplateLiteralFragment(): TemplateLiteralFragment { + return parseLiteralLikeNode(token, /*internName*/ false); + } + + function parseLiteralLikeNode(kind: SyntaxKind, internName: boolean): LiteralLikeNode { + const node = createNode(kind); const text = scanner.getTokenValue(); node.text = internName ? internIdentifier(text) : text; @@ -2392,7 +2404,7 @@ namespace ts { const node = tryParse(parseKeywordAndNoDot); return node || parseTypeReferenceOrTypePredicate(); case SyntaxKind.StringLiteral: - return parseLiteralNode(/*internName*/ true); + return parseStringLiteralTypeNode(); case SyntaxKind.VoidKeyword: return parseTokenNode(); case SyntaxKind.ThisKeyword: diff --git a/src/compiler/types.ts b/src/compiler/types.ts index cfa28c46161..b4edfe2fa99 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -205,6 +205,7 @@ namespace ts { IntersectionType, ParenthesizedType, ThisType, + StringLiteralType, // Binding patterns ObjectBindingPattern, ArrayBindingPattern, @@ -350,7 +351,7 @@ namespace ts { FirstFutureReservedWord = ImplementsKeyword, LastFutureReservedWord = YieldKeyword, FirstTypeNode = TypePredicate, - LastTypeNode = ThisType, + LastTypeNode = StringLiteralType, FirstPunctuation = OpenBraceToken, LastPunctuation = CaretEqualsToken, FirstToken = Unknown, @@ -790,10 +791,13 @@ namespace ts { type: TypeNode; } - // Note that a StringLiteral AST node is both an Expression and a TypeNode. The latter is - // because string literals can appear in type annotations as well. + // @kind(SyntaxKind.StringLiteralType) + export interface StringLiteralTypeNode extends LiteralLikeNode, TypeNode { + _stringLiteralTypeBrand: any; + } + // @kind(SyntaxKind.StringLiteral) - export interface StringLiteral extends LiteralExpression, TypeNode { + export interface StringLiteral extends LiteralExpression { _stringLiteralBrand: any; } @@ -911,24 +915,32 @@ namespace ts { body: ConciseBody; } + export interface LiteralLikeNode extends Node { + text: string; + isUnterminated?: boolean; + hasExtendedUnicodeEscape?: boolean; + } + // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral, // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters. // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1". // @kind(SyntaxKind.NumericLiteral) // @kind(SyntaxKind.RegularExpressionLiteral) // @kind(SyntaxKind.NoSubstitutionTemplateLiteral) + export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression { + _literalExpressionBrand: any; + } + // @kind(SyntaxKind.TemplateHead) // @kind(SyntaxKind.TemplateMiddle) // @kind(SyntaxKind.TemplateTail) - export interface LiteralExpression extends PrimaryExpression { - text: string; - isUnterminated?: boolean; - hasExtendedUnicodeEscape?: boolean; + export interface TemplateLiteralFragment extends LiteralLikeNode { + _templateLiteralFragmentBrand: any; } // @kind(SyntaxKind.TemplateExpression) export interface TemplateExpression extends PrimaryExpression { - head: LiteralExpression; + head: TemplateLiteralFragment; templateSpans: NodeArray; } @@ -937,7 +949,7 @@ namespace ts { // @kind(SyntaxKind.TemplateSpan) export interface TemplateSpan extends Node { expression: Expression; - literal: LiteralExpression; + literal: TemplateLiteralFragment; } // @kind(SyntaxKind.ParenthesizedExpression) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 1e4ee1bed47..22228343cf3 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -464,9 +464,6 @@ namespace ts { return true; case SyntaxKind.VoidKeyword: return node.parent.kind !== SyntaxKind.VoidExpression; - case SyntaxKind.StringLiteral: - // Specialized signatures can have string literals as their parameters' type names - return node.parent.kind === SyntaxKind.Parameter; case SyntaxKind.ExpressionWithTypeArguments: return !isExpressionWithTypeArgumentsInClassExtendsClause(node); diff --git a/src/services/services.ts b/src/services/services.ts index 95179ac0bc0..995966bdd52 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3535,6 +3535,7 @@ namespace ts { function isInStringOrRegularExpressionOrTemplateLiteral(contextToken: Node): boolean { if (contextToken.kind === SyntaxKind.StringLiteral + || contextToken.kind === SyntaxKind.StringLiteralType || contextToken.kind === SyntaxKind.RegularExpressionLiteral || isTemplateLiteralKind(contextToken.kind)) { let start = contextToken.getStart(); @@ -6532,6 +6533,7 @@ namespace ts { case SyntaxKind.PropertyAccessExpression: case SyntaxKind.QualifiedName: case SyntaxKind.StringLiteral: + case SyntaxKind.StringLiteralType: case SyntaxKind.FalseKeyword: case SyntaxKind.TrueKeyword: case SyntaxKind.NullKeyword: @@ -6993,7 +6995,7 @@ namespace ts { else if (tokenKind === SyntaxKind.NumericLiteral) { return ClassificationType.numericLiteral; } - else if (tokenKind === SyntaxKind.StringLiteral) { + else if (tokenKind === SyntaxKind.StringLiteral || tokenKind === SyntaxKind.StringLiteralType) { return ClassificationType.stringLiteral; } else if (tokenKind === SyntaxKind.RegularExpressionLiteral) { @@ -7912,7 +7914,7 @@ namespace ts { addResult(start, end, classFromKind(token)); if (end >= text.length) { - if (token === SyntaxKind.StringLiteral) { + if (token === SyntaxKind.StringLiteral || token === SyntaxKind.StringLiteralType) { // Check to see if we finished up on a multiline string literal. let tokenText = scanner.getTokenText(); if (scanner.isUnterminated()) { @@ -8062,6 +8064,7 @@ namespace ts { case SyntaxKind.NumericLiteral: return ClassificationType.numericLiteral; case SyntaxKind.StringLiteral: + case SyntaxKind.StringLiteralType: return ClassificationType.stringLiteral; case SyntaxKind.RegularExpressionLiteral: return ClassificationType.regularExpressionLiteral; diff --git a/src/services/utilities.ts b/src/services/utilities.ts index a7198b4cc6d..b3b4ec31a02 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -257,14 +257,14 @@ namespace ts { return syntaxList; } - /* Gets the token whose text has range [start, end) and + /* Gets the token whose text has range [start, end) and * position >= start and (position < end or (position === end && token is keyword or identifier)) */ export function getTouchingWord(sourceFile: SourceFile, position: number): Node { return getTouchingToken(sourceFile, position, n => isWord(n.kind)); } - /* Gets the token whose text has range [start, end) and position >= start + /* Gets the token whose text has range [start, end) and position >= start * and (position < end or (position === end && token is keyword or identifier or numeric\string litera)) */ export function getTouchingPropertyName(sourceFile: SourceFile, position: number): Node { @@ -391,8 +391,8 @@ namespace ts { const start = child.getStart(sourceFile); const lookInPreviousChild = (start >= position) || // cursor in the leading trivia - (child.kind === SyntaxKind.JsxText && start === child.end); // whitespace only JsxText - + (child.kind === SyntaxKind.JsxText && start === child.end); // whitespace only JsxText + if (lookInPreviousChild) { // actual start of the node is past the position - previous token should be at the end of previous child let candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ i); @@ -407,7 +407,7 @@ namespace ts { Debug.assert(startNode !== undefined || n.kind === SyntaxKind.SourceFile); - // Here we know that none of child token nodes embrace the position, + // Here we know that none of child token nodes embrace the position, // the only known case is when position is at the end of the file. // Try to find the rightmost token in the file without filtering. // Namely we are skipping the check: 'position < node.end' @@ -429,7 +429,7 @@ namespace ts { export function isInString(sourceFile: SourceFile, position: number) { let token = getTokenAtPosition(sourceFile, position); - return token && token.kind === SyntaxKind.StringLiteral && position > token.getStart(); + return token && (token.kind === SyntaxKind.StringLiteral || token.kind === SyntaxKind.StringLiteralType) && position > token.getStart(); } export function isInComment(sourceFile: SourceFile, position: number) { @@ -445,7 +445,7 @@ namespace ts { if (token && position <= token.getStart()) { let commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos); - + // The end marker of a single-line comment does not include the newline character. // In the following case, we are inside a comment (^ denotes the cursor position): // @@ -565,6 +565,7 @@ namespace ts { export function isStringOrRegularExpressionOrTemplateLiteral(kind: SyntaxKind): boolean { if (kind === SyntaxKind.StringLiteral + || kind === SyntaxKind.StringLiteralType || kind === SyntaxKind.RegularExpressionLiteral || isTemplateLiteralKind(kind)) { return true; From 9b0231d9b897b44b75d7828afe61bb1048beff38 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 19 Nov 2015 17:50:28 -0800 Subject: [PATCH 25/51] Minor change to getStringLiteralType --- src/compiler/checker.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a155387d2ee..61dabb6d50b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4531,8 +4531,7 @@ namespace ts { return links.resolvedType; } - function getStringLiteralType(node: StringLiteral | StringLiteralTypeNode): StringLiteralType { - const text = node.text; + function getStringLiteralType(text: string): StringLiteralType { if (hasProperty(stringLiteralTypes, text)) { return stringLiteralTypes[text]; } @@ -4545,7 +4544,7 @@ namespace ts { function getTypeFromStringLiteral(node: StringLiteral | StringLiteralTypeNode): Type { const links = getNodeLinks(node); if (!links.resolvedType) { - links.resolvedType = getStringLiteralType(node); + links.resolvedType = getStringLiteralType(node.text); } return links.resolvedType; } @@ -8747,7 +8746,7 @@ namespace ts { // for the argument. In that case, we should check the argument. if (argType === undefined) { argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors - ? getStringLiteralType(arg) + ? getStringLiteralType((arg).text) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); } @@ -8942,7 +8941,7 @@ namespace ts { case SyntaxKind.Identifier: case SyntaxKind.NumericLiteral: case SyntaxKind.StringLiteral: - return getStringLiteralType(element.name); + return getStringLiteralType((element.name).text); case SyntaxKind.ComputedPropertyName: const nameType = checkComputedPropertyName(element.name); @@ -10564,7 +10563,8 @@ namespace ts { function checkStringLiteralExpression(node: StringLiteral): Type { const contextualType = getContextualType(node); if (contextualType && contextualTypeIsStringLiteralType(contextualType)) { - return getStringLiteralType(node); + // TODO (drosen): Consider using getTypeFromStringLiteral instead + return getStringLiteralType(node.text); } return stringType; From 71b98e0615b1b9c216235bc24f848e5410950418 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Fri, 20 Nov 2015 10:56:17 -0800 Subject: [PATCH 26/51] apply 'noImplicitReturns' check for functions that don't have type annotations --- src/compiler/checker.ts | 44 ++-- .../reference/reachabilityChecks6.errors.txt | 162 ++++++++++++ .../reference/reachabilityChecks6.js | 247 ++++++++++++++++++ tests/cases/compiler/reachabilityChecks6.ts | 131 ++++++++++ 4 files changed, 561 insertions(+), 23 deletions(-) create mode 100644 tests/baselines/reference/reachabilityChecks6.errors.txt create mode 100644 tests/baselines/reference/reachabilityChecks6.js create mode 100644 tests/cases/compiler/reachabilityChecks6.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 1b6b31f9586..53e9cc720ce 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9815,13 +9815,19 @@ namespace ts { // An explicitly typed function whose return type isn't the Void or the Any type // must have at least one return statement somewhere in its body. // An exception to this rule is if the function implementation consists of a single 'throw' statement. + // @param returnType - return type of the function, can be undefined if return type is not explicitly specified function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func: FunctionLikeDeclaration, returnType: Type): void { if (!produceDiagnostics) { return; } - // Functions that return 'void' or 'any' don't need any return expressions. - if (returnType === voidType || isTypeAny(returnType)) { + // Functions with explicitly specified return type which is either 'void' or 'any' don't need any return expressions. + if (returnType && (returnType === voidType || isTypeAny(returnType))) { + return; + } + + // if return type is not specified then we'll do the check only if 'noImplicitReturns' option is set + if (!returnType && !compilerOptions.noImplicitReturns) { return; } @@ -9831,13 +9837,14 @@ namespace ts { return; } - if (func.flags & NodeFlags.HasExplicitReturn) { + if (!returnType || func.flags & NodeFlags.HasExplicitReturn) { if (compilerOptions.noImplicitReturns) { - error(func.type, Diagnostics.Not_all_code_paths_return_a_value); + error(func.type || func, Diagnostics.Not_all_code_paths_return_a_value); } } else { // This function does not conform to the specification. + // NOTE: having returnType !== undefined is a precondition for entering this branch so func.type will always be present error(func.type, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value); } } @@ -9912,14 +9919,10 @@ namespace ts { emitAwaiter = true; } - const returnType = node.type && getTypeFromTypeNode(node.type); - let promisedType: Type; - if (returnType && isAsync) { - promisedType = checkAsyncFunctionReturnType(node); - } - - if (returnType && !node.asteriskToken) { - checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType); + const returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type)); + if (!node.asteriskToken) { + // return is not necessary in the body of generators + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType); } if (node.body) { @@ -9942,13 +9945,13 @@ namespace ts { // check assignability of the awaited type of the expression body against the promised type of // its return type annotation. const exprType = checkExpression(node.body); - if (returnType) { + if (returnOrPromisedType) { if (isAsync) { const awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member); - checkTypeAssignableTo(awaitedType, promisedType, node.body); + checkTypeAssignableTo(awaitedType, returnOrPromisedType, node.body); } else { - checkTypeAssignableTo(exprType, returnType, node.body); + checkTypeAssignableTo(exprType, returnOrPromisedType, node.body); } } @@ -12088,14 +12091,9 @@ namespace ts { } checkSourceElement(node.body); - if (node.type && !isAccessor(node.kind) && !node.asteriskToken) { - const returnType = getTypeFromTypeNode(node.type); - let promisedType: Type; - if (isAsync) { - promisedType = checkAsyncFunctionReturnType(node); - } - - checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType); + if (!isAccessor(node.kind) && !node.asteriskToken) { + const returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type)); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType); } if (produceDiagnostics && !node.type) { diff --git a/tests/baselines/reference/reachabilityChecks6.errors.txt b/tests/baselines/reference/reachabilityChecks6.errors.txt new file mode 100644 index 00000000000..5b78891afb3 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks6.errors.txt @@ -0,0 +1,162 @@ +tests/cases/compiler/reachabilityChecks6.ts(6,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(19,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(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 (10 errors) ==== + + function f0(x) { + while (true); + } + + function f1(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + if (x) { + return 1 + } + } + + function f2(x) { + while (x) { + throw new Error(); + } + return 1; + } + + function f3(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + while (x) { + throw new Error(); + } + } + + function f3_1 (x) { + while (x) { + } + throw new Error(); + } + + function f4(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + try { + if (x) { + return 1; + } + } + catch (e) { + } + } + + function f5(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } + } + + function f6(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + try { + if (x) { + return 1; + } + else + { + throw new Error(); + } + } + catch (e) { + } + } + + function f7(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } + } + + function f8(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + try { + if (true) { + x++; + } + else { + return 1; + ~~~~~~ +!!! error TS7027: Unreachable code detected. + } + } + catch (e) { + return 1; + } + } + + function f9(x) { + ~~ +!!! error TS7030: Not all code paths return a value. + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } + } + + function f10(x) { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } + } + + function f11(x) { + ~~~ +!!! error TS7030: Not all code paths return a value. + test: + try { + do { + do { + break test; + } while (true); + x++; + ~ +!!! error TS7027: Unreachable code detected. + } while (true); + } + catch (e) { + return 1; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks6.js b/tests/baselines/reference/reachabilityChecks6.js new file mode 100644 index 00000000000..9be23d32048 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks6.js @@ -0,0 +1,247 @@ +//// [reachabilityChecks6.ts] + +function f0(x) { + while (true); +} + +function f1(x) { + if (x) { + return 1 + } +} + +function f2(x) { + while (x) { + throw new Error(); + } + return 1; +} + +function f3(x) { + while (x) { + throw new Error(); + } +} + +function f3_1 (x) { + while (x) { + } + throw new Error(); +} + +function f4(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + } +} + +function f5(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } +} + +function f6(x) { + try { + if (x) { + return 1; + } + else + { + throw new Error(); + } + } + catch (e) { + } +} + +function f7(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } +} + +function f8(x) { + try { + if (true) { + x++; + } + else { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f9(x) { + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f10(x) { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } +} + +function f11(x) { + test: + try { + do { + do { + break test; + } while (true); + x++; + } while (true); + } + catch (e) { + return 1; + } +} + +//// [reachabilityChecks6.js] +function f0(x) { + while (true) + ; +} +function f1(x) { + if (x) { + return 1; + } +} +function f2(x) { + while (x) { + throw new Error(); + } + return 1; +} +function f3(x) { + while (x) { + throw new Error(); + } +} +function f3_1(x) { + while (x) { + } + throw new Error(); +} +function f4(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + } +} +function f5(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } +} +function f6(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + } +} +function f7(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } +} +function f8(x) { + try { + if (true) { + x++; + } + else { + return 1; + } + } + catch (e) { + return 1; + } +} +function f9(x) { + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } +} +function f10(x) { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } +} +function f11(x) { + test: try { + do { + do { + break test; + } while (true); + x++; + } while (true); + } + catch (e) { + return 1; + } +} diff --git a/tests/cases/compiler/reachabilityChecks6.ts b/tests/cases/compiler/reachabilityChecks6.ts new file mode 100644 index 00000000000..725563a4488 --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks6.ts @@ -0,0 +1,131 @@ +// @allowUnreachableCode: false +// @noImplicitReturns: true + +function f0(x) { + while (true); +} + +function f1(x) { + if (x) { + return 1 + } +} + +function f2(x) { + while (x) { + throw new Error(); + } + return 1; +} + +function f3(x) { + while (x) { + throw new Error(); + } +} + +function f3_1 (x) { + while (x) { + } + throw new Error(); +} + +function f4(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + } +} + +function f5(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } +} + +function f6(x) { + try { + if (x) { + return 1; + } + else + { + throw new Error(); + } + } + catch (e) { + } +} + +function f7(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } +} + +function f8(x) { + try { + if (true) { + x++; + } + else { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f9(x) { + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f10(x) { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } +} + +function f11(x) { + test: + try { + do { + do { + break test; + } while (true); + x++; + } while (true); + } + catch (e) { + return 1; + } +} \ No newline at end of file From 02a9b11e0e1dbc5cf51e6c9d7fac9ebe42f1e249 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 20 Nov 2015 13:41:41 -0800 Subject: [PATCH 27/51] Accpet new baselines --- .../getEmitOutputSingleFile2.baseline | 2 +- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- ...ultifolderSpecifyOutputFile.dts.errors.txt | 41 ------------------- 10 files changed, 1 insertion(+), 370 deletions(-) delete mode 100644 tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.dts.errors.txt delete mode 100644 tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt diff --git a/tests/baselines/reference/getEmitOutputSingleFile2.baseline b/tests/baselines/reference/getEmitOutputSingleFile2.baseline index 3022dcf68d8..21e28eb7feb 100644 --- a/tests/baselines/reference/getEmitOutputSingleFile2.baseline +++ b/tests/baselines/reference/getEmitOutputSingleFile2.baseline @@ -23,7 +23,7 @@ declare class Foo { x: string; y: number; } -declare module "tests/cases/fourslash/inputFile3" { +declare module "inputFile3" { export var foo: number; export var bar: string; } diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt deleted file mode 100644 index d827a2492f8..00000000000 --- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.dts.errors.txt +++ /dev/null @@ -1,41 +0,0 @@ -bin/test.d.ts(9,16): error TS2436: Ambient module declaration cannot specify relative module name. -bin/test.d.ts(19,5): error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. -bin/test.d.ts(19,25): error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - - -==== bin/test.d.ts (3 errors) ==== - declare module "ref/m1" { - export var m1_a1: number; - export class m1_c1 { - m1_c1_p1: number; - } - export var m1_instance1: m1_c1; - export function m1_f1(): m1_c1; - } - declare module "../outputdir_module_multifolder_ref/m2" { - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2436: Ambient module declaration cannot specify relative module name. - export var m2_a1: number; - export class m2_c1 { - m2_c1_p1: number; - } - export var m2_instance1: m2_c1; - export function m2_f1(): m2_c1; - } - declare module "test" { - import m1 = require("ref/m1"); - import m2 = require("../outputdir_module_multifolder_ref/m2"); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2439: Import or export declaration in an ambient module declaration cannot reference module through relative module name. - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2307: Cannot find module '../outputdir_module_multifolder_ref/m2'. - export var a1: number; - export class c1 { - p1: number; - } - export var instance1: c1; - export function f1(): c1; - export var a2: typeof m1.m1_c1; - export var a3: typeof m2.m2_c1; - } - \ No newline at end of file From 8d3fca9de8d95371ed4a08c648960524c8c3d2f5 Mon Sep 17 00:00:00 2001 From: Yui T Date: Fri, 20 Nov 2015 16:26:13 -0800 Subject: [PATCH 28/51] apply tslint rule to scripts\tslint --- Jakefile.js | 14 ++++++++++++-- scripts/tslint/typeOperatorSpacingRule.ts | 4 ++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/Jakefile.js b/Jakefile.js index 5dfbcc26d74..2c7442a4916 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -106,6 +106,16 @@ var serverCoreSources = [ return path.join(serverDirectory, f); }); +var scriptSources = [ + "tslint/booleanTriviaRule.ts", + "tslint/nextLineRule.ts", + "tslint/noNullRule.ts", + "tslint/preferConstRule.ts", + "tslint/typeOperatorSpacingRule.ts" +].map(function (f) { + return path.join(scriptsDirectory, f); +}); + var serverSources = serverCoreSources.concat(servicesSources); var languageServiceLibrarySources = [ @@ -365,7 +375,6 @@ file(builtGeneratedDiagnosticMessagesJSON,[generatedDiagnosticMessagesJSON], fun desc("Generates a diagnostic file in TypeScript based on an input JSON file"); task("generate-diagnostics", [diagnosticInfoMapTs]); - // Publish nightly var configureNightlyJs = path.join(scriptsDirectory, "configureNightly.js"); var configureNightlyTs = path.join(scriptsDirectory, "configureNightly.ts"); @@ -909,7 +918,8 @@ function lintFileAsync(options, path, cb) { var lintTargets = compilerSources .concat(harnessCoreSources) - .concat(serverCoreSources); + .concat(serverCoreSources) + .concat(scriptSources) desc("Runs tslint on the compiler sources"); task("lint", ["build-rules"], function() { diff --git a/scripts/tslint/typeOperatorSpacingRule.ts b/scripts/tslint/typeOperatorSpacingRule.ts index 4196d024768..7ceef2372bf 100644 --- a/scripts/tslint/typeOperatorSpacingRule.ts +++ b/scripts/tslint/typeOperatorSpacingRule.ts @@ -13,10 +13,10 @@ export class Rule extends Lint.Rules.AbstractRule { class TypeOperatorSpacingWalker extends Lint.RuleWalker { public visitNode(node: ts.Node) { if (node.kind === ts.SyntaxKind.UnionType || node.kind === ts.SyntaxKind.IntersectionType) { - let types = (node).types; + const types = (node).types; let expectedStart = types[0].end + 2; // space, | or & for (let i = 1; i < types.length; i++) { - let currentType = types[i]; + const currentType = types[i]; if (expectedStart !== currentType.pos || currentType.getLeadingTriviaWidth() !== 1) { const failure = this.createFailure(currentType.pos, currentType.getWidth(), Rule.FAILURE_STRING); this.addFailure(failure); From 97f0bfcd72d0fe9602e55da409d39619b2bb0c28 Mon Sep 17 00:00:00 2001 From: Yui T Date: Fri, 20 Nov 2015 16:28:58 -0800 Subject: [PATCH 29/51] apply tslint rule to scripts\tslint --- Jakefile.js | 14 ++++++++++++-- scripts/tslint/typeOperatorSpacingRule.ts | 4 ++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/Jakefile.js b/Jakefile.js index 5dfbcc26d74..7cd36aaa8bd 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -106,6 +106,16 @@ var serverCoreSources = [ return path.join(serverDirectory, f); }); +var scriptSources = [ + "tslint/booleanTriviaRule.ts", + "tslint/nextLineRule.ts", + "tslint/noNullRule.ts", + "tslint/preferConstRule.ts", + "tslint/typeOperatorSpacingRule.ts" +].map(function (f) { + return path.join(scriptsDirectory, f); +}); + var serverSources = serverCoreSources.concat(servicesSources); var languageServiceLibrarySources = [ @@ -365,7 +375,6 @@ file(builtGeneratedDiagnosticMessagesJSON,[generatedDiagnosticMessagesJSON], fun desc("Generates a diagnostic file in TypeScript based on an input JSON file"); task("generate-diagnostics", [diagnosticInfoMapTs]); - // Publish nightly var configureNightlyJs = path.join(scriptsDirectory, "configureNightly.js"); var configureNightlyTs = path.join(scriptsDirectory, "configureNightly.ts"); @@ -909,7 +918,8 @@ function lintFileAsync(options, path, cb) { var lintTargets = compilerSources .concat(harnessCoreSources) - .concat(serverCoreSources); + .concat(serverCoreSources) + .concat(scriptSources); desc("Runs tslint on the compiler sources"); task("lint", ["build-rules"], function() { diff --git a/scripts/tslint/typeOperatorSpacingRule.ts b/scripts/tslint/typeOperatorSpacingRule.ts index 4196d024768..7ceef2372bf 100644 --- a/scripts/tslint/typeOperatorSpacingRule.ts +++ b/scripts/tslint/typeOperatorSpacingRule.ts @@ -13,10 +13,10 @@ export class Rule extends Lint.Rules.AbstractRule { class TypeOperatorSpacingWalker extends Lint.RuleWalker { public visitNode(node: ts.Node) { if (node.kind === ts.SyntaxKind.UnionType || node.kind === ts.SyntaxKind.IntersectionType) { - let types = (node).types; + const types = (node).types; let expectedStart = types[0].end + 2; // space, | or & for (let i = 1; i < types.length; i++) { - let currentType = types[i]; + const currentType = types[i]; if (expectedStart !== currentType.pos || currentType.getLeadingTriviaWidth() !== 1) { const failure = this.createFailure(currentType.pos, currentType.getWidth(), Rule.FAILURE_STRING); this.addFailure(failure); From 5eb8f71ee1962cfeb5441d9029121cef182e8e2b Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Sun, 22 Nov 2015 22:06:05 -0800 Subject: [PATCH 30/51] addressed PR feedback --- src/compiler/checker.ts | 14 ++++--- .../reference/reachabilityChecks7.errors.txt | 21 ++++++++++ .../reference/reachabilityChecks7.js | 42 +++++++++++++++++++ tests/cases/compiler/reachabilityChecks7.ts | 14 +++++++ 4 files changed, 85 insertions(+), 6 deletions(-) create mode 100644 tests/baselines/reference/reachabilityChecks7.errors.txt create mode 100644 tests/baselines/reference/reachabilityChecks7.js create mode 100644 tests/cases/compiler/reachabilityChecks7.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 53e9cc720ce..1a0440be2c7 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9811,17 +9811,19 @@ namespace ts { return aggregatedTypes; } - // TypeScript Specification 1.0 (6.3) - July 2014 - // An explicitly typed function whose return type isn't the Void or the Any type - // must have at least one return statement somewhere in its body. - // An exception to this rule is if the function implementation consists of a single 'throw' statement. - // @param returnType - return type of the function, can be undefined if return type is not explicitly specified + /* + *TypeScript Specification 1.0 (6.3) - July 2014 + * An explicitly typed function whose return type isn't the Void or the Any type + * must have at least one return statement somewhere in its body. + * An exception to this rule is if the function implementation consists of a single 'throw' statement. + * @param returnType - return type of the function, can be undefined if return type is not explicitly specified + */ function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func: FunctionLikeDeclaration, returnType: Type): void { if (!produceDiagnostics) { return; } - // Functions with explicitly specified return type which is either 'void' or 'any' don't need any return expressions. + // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions. if (returnType && (returnType === voidType || isTypeAny(returnType))) { return; } diff --git a/tests/baselines/reference/reachabilityChecks7.errors.txt b/tests/baselines/reference/reachabilityChecks7.errors.txt new file mode 100644 index 00000000000..9e8f803f957 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks7.errors.txt @@ -0,0 +1,21 @@ +tests/cases/compiler/reachabilityChecks7.ts(3,16): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks7.ts(6,9): error TS7030: Not all code paths return a value. + + +==== tests/cases/compiler/reachabilityChecks7.ts (2 errors) ==== + + // async function without return type annotation - error + async function f1() { + ~~ +!!! error TS7030: Not all code paths return a value. + } + + let x = async function() { + ~~~~~ +!!! error TS7030: Not all code paths return a value. + } + + // async function with which promised type is void - return can be omitted + async function f2(): Promise { + + } \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks7.js b/tests/baselines/reference/reachabilityChecks7.js new file mode 100644 index 00000000000..f9579d5828d --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks7.js @@ -0,0 +1,42 @@ +//// [reachabilityChecks7.ts] + +// async function without return type annotation - error +async function f1() { +} + +let x = async function() { +} + +// async function with which promised type is void - return can be omitted +async function f2(): Promise { + +} + +//// [reachabilityChecks7.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) { + return new Promise(function (resolve, reject) { + generator = generator.call(thisArg, _arguments); + function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); } + function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } + function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } + function step(verb, value) { + var result = generator[verb](value); + result.done ? resolve(result.value) : cast(result.value).then(onfulfill, onreject); + } + step("next", void 0); + }); +}; +// async function without return type annotation - error +function f1() { + return __awaiter(this, void 0, Promise, function* () { + }); +} +let x = function () { + return __awaiter(this, void 0, Promise, function* () { + }); +}; +// async function with which promised type is void - return can be omitted +function f2() { + return __awaiter(this, void 0, Promise, function* () { + }); +} diff --git a/tests/cases/compiler/reachabilityChecks7.ts b/tests/cases/compiler/reachabilityChecks7.ts new file mode 100644 index 00000000000..11febb320d6 --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks7.ts @@ -0,0 +1,14 @@ +// @target: ES6 +// @noImplicitReturns: true + +// async function without return type annotation - error +async function f1() { +} + +let x = async function() { +} + +// async function with which promised type is void - return can be omitted +async function f2(): Promise { + +} \ No newline at end of file From 5c23a5f11e6669b1e6d33d4ceece69db8f434749 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Mon, 23 Nov 2015 22:38:05 -0800 Subject: [PATCH 31/51] Extract source map generation logic out of the emitter. --- Jakefile.js | 8 +- src/compiler/core.ts | 27 +++ src/compiler/emitter.ts | 481 +++++--------------------------------- src/compiler/scanner.ts | 10 +- src/compiler/sourcemap.ts | 416 +++++++++++++++++++++++++++++++++ src/compiler/utilities.ts | 21 ++ 6 files changed, 530 insertions(+), 433 deletions(-) create mode 100644 src/compiler/sourcemap.ts diff --git a/Jakefile.js b/Jakefile.js index 5dfbcc26d74..c76927b2b45 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -40,6 +40,7 @@ var compilerSources = [ "utilities.ts", "binder.ts", "checker.ts", + "sourcemap.ts", "declarationEmitter.ts", "emitter.ts", "program.ts", @@ -59,6 +60,7 @@ var servicesSources = [ "utilities.ts", "binder.ts", "checker.ts", + "sourcemap.ts", "declarationEmitter.ts", "emitter.ts", "program.ts", @@ -466,7 +468,7 @@ compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].conca var nodeDefinitionsFileContents = definitionFileContents + "\r\nexport = ts;"; fs.writeFileSync(nodeDefinitionsFile, nodeDefinitionsFileContents); - // Node package definition file to be distributed without the package. Created by replacing + // Node package definition file to be distributed without the package. Created by replacing // 'ts' namespace with '"typescript"' as a module. var nodeStandaloneDefinitionsFileContents = definitionFileContents.replace(/declare (namespace|module) ts/g, 'declare module "typescript"'); fs.writeFileSync(nodeStandaloneDefinitionsFile, nodeStandaloneDefinitionsFileContents); @@ -875,7 +877,7 @@ var tslintRulesOutFiles = tslintRules.map(function(p) { desc("Compiles tslint rules to js"); task("build-rules", tslintRulesOutFiles); tslintRulesFiles.forEach(function(ruleFile, i) { - compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); + compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); }); function getLinterOptions() { @@ -937,7 +939,7 @@ function lintWatchFile(filename) { if (event !== "change") { return; } - + if (!lintSemaphores[filename]) { lintSemaphores[filename] = true; lintFileAsync(getLinterOptions(), filename, function(err, result) { diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 79f0251c565..7590f8c73cd 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -356,6 +356,33 @@ namespace ts { return result; } + /** + * Reduce the properties of a map. + * + * @param map The map to reduce + * @param callback An aggregation function that is called for each entry in the map + * @param initial The initial value for the reduction. + */ + export function reduceProperties(map: Map, callback: (aggregate: U, value: T, key: string) => U, initial: U): U { + let result = initial; + if (map) { + for (const key in map) { + if (hasProperty(map, key)) { + result = callback(result, map[key], String(key)); + } + } + } + + return result; + } + + /** + * Tests whether a value is an array. + */ + export function isArray(value: any): value is any[] { + return Array.isArray ? Array.isArray(value) : typeof value === "object" && value instanceof Array; + } + export function memoize(callback: () => T): () => T { let value: T; return () => { diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index d2f9abc7354..ac7aa0f00dc 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1,4 +1,5 @@ /// +/// /// /* @internal */ @@ -458,6 +459,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi const writer = createTextWriter(newLine); const { write, writeTextOfNode, writeLine, increaseIndent, decreaseIndent } = writer; + const sourceMap = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? createSourceMapWriter(host, writer) : getNullSourceMapWriter(); + const { setSourceFile, emitStart, emitEnd, emitPos, pushScope: scopeEmitStart, popScope: scopeEmitEnd } = sourceMap; + let currentSourceFile: SourceFile; let currentText: string; let currentLineMap: number[]; @@ -492,38 +496,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi let exportEquals: ExportAssignment; let hasExportStars: boolean; - /** Write emitted output to disk */ - let writeEmittedFiles = writeJavaScriptFile; - let detachedCommentsInfo: { nodePos: number; detachedCommentEndPos: number }[]; - let writeComment = writeCommentRange; - - /** Emit a node */ - let emit = emitNodeWithCommentsAndWithoutSourcemap; - - /** Called just before starting emit of a node */ - let emitStart = function (node: Node) { }; - - /** Called once the emit of the node is done */ - let emitEnd = function (node: Node) { }; - - /** Emit the text for the given token that comes after startPos - * This by default writes the text provided with the given tokenKind - * but if optional emitFn callback is provided the text is emitted using the callback instead of default text - * @param tokenKind the kind of the token to search and emit - * @param startPos the position in the source to start searching for the token - * @param emitFn if given will be invoked to emit the text instead of actual token emit */ - let emitToken = emitTokenText; - - /** Called to before starting the lexical scopes as in function/class in the emitted code because of node - * @param scopeDeclaration node that starts the lexical scope - * @param scopeName Optional name of this scope instead of deducing one from the declaration node */ - let scopeEmitStart = function(scopeDeclaration: Node, scopeName?: string) { }; - - /** Called after coming out of the scope */ - let scopeEmitEnd = function() { }; - /** Sourcemap data that will get encoded */ let sourceMapData: SourceMapData; @@ -549,18 +523,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi [ModuleKind.CommonJS]() {}, }; - return doEmit; function doEmit(jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) { + sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit); generatedNameSet = {}; nodeToGeneratedName = []; isOwnFileEmit = !isBundledEmit; - if (compilerOptions.sourceMap || compilerOptions.inlineSourceMap) { - initializeEmitterWithSourceMaps(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit); - } - // Emit helpers from all the files if (isBundledEmit && modulekind) { forEach(sourceFiles, emitEmitHelpers); @@ -570,9 +540,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi forEach(sourceFiles, emitSourceFile); writeLine(); - writeEmittedFiles(writer.getText(), jsFilePath, /*writeByteOrderMark*/ compilerOptions.emitBOM); + + const sourceMappingURL = sourceMap.getSourceMappingURL(); + if (sourceMappingURL) { + write(`//# sourceMappingURL=${sourceMappingURL}`); + } + + writeEmittedFiles(writer.getText(), jsFilePath, sourceMapFilePath, /*writeByteOrderMark*/ compilerOptions.emitBOM); // reset the state + sourceMap.reset(); writer.reset(); currentSourceFile = undefined; currentText = undefined; @@ -611,7 +588,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi currentFileIdentifiers = sourceFile.identifiers; isCurrentFileExternalModule = isExternalModule(sourceFile); - emit(sourceFile); + setSourceFile(sourceFile); + emitNodeWithCommentsAndWithoutSourcemap(sourceFile); } function isUniqueName(name: string): boolean { @@ -708,399 +686,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = unescapeIdentifier(generateNameForNode(node))); } - function initializeEmitterWithSourceMaps(jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) { - let sourceMapDir: string; // The directory in which sourcemap will be - - // Current source map file and its index in the sources list - let sourceMapSourceIndex = -1; - - // Names and its index map - const sourceMapNameIndexMap: Map = {}; - const sourceMapNameIndices: number[] = []; - function getSourceMapNameIndex() { - return sourceMapNameIndices.length ? lastOrUndefined(sourceMapNameIndices) : -1; + /** Write emitted output to disk */ + function writeEmittedFiles(emitOutput: string, jsFilePath: string, sourceMapFilePath: string, writeByteOrderMark: boolean) { + if (compilerOptions.sourceMap && !compilerOptions.inlineSourceMap) { + writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap.getText(), /*writeByteOrderMark*/ false); } - // Last recorded and encoded spans - let lastRecordedSourceMapSpan: SourceMapSpan; - let lastEncodedSourceMapSpan: SourceMapSpan = { - emittedLine: 1, - emittedColumn: 1, - sourceLine: 1, - sourceColumn: 1, - sourceIndex: 0 - }; - let lastEncodedNameIndex = 0; - - // Encoding for sourcemap span - function encodeLastRecordedSourceMapSpan() { - if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) { - return; - } - - let prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; - // Line/Comma delimiters - if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) { - // Emit comma to separate the entry - if (sourceMapData.sourceMapMappings) { - sourceMapData.sourceMapMappings += ","; - } - } - else { - // Emit line delimiters - for (let encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) { - sourceMapData.sourceMapMappings += ";"; - } - prevEncodedEmittedColumn = 1; - } - - // 1. Relative Column 0 based - sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn); - - // 2. Relative sourceIndex - sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex); - - // 3. Relative sourceLine 0 based - sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine); - - // 4. Relative sourceColumn 0 based - sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn); - - // 5. Relative namePosition 0 based - if (lastRecordedSourceMapSpan.nameIndex >= 0) { - sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex); - lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex; - } - - lastEncodedSourceMapSpan = lastRecordedSourceMapSpan; - sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan); - - function base64VLQFormatEncode(inValue: number) { - function base64FormatEncode(inValue: number) { - if (inValue < 64) { - return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(inValue); - } - throw TypeError(inValue + ": not a 64 based value"); - } - - // Add a new least significant bit that has the sign of the value. - // if negative number the least significant bit that gets added to the number has value 1 - // else least significant bit value that gets added is 0 - // eg. -1 changes to binary : 01 [1] => 3 - // +1 changes to binary : 01 [0] => 2 - if (inValue < 0) { - inValue = ((-inValue) << 1) + 1; - } - else { - inValue = inValue << 1; - } - - // Encode 5 bits at a time starting from least significant bits - let encodedStr = ""; - do { - let currentDigit = inValue & 31; // 11111 - inValue = inValue >> 5; - if (inValue > 0) { - // There are still more digits to decode, set the msb (6th bit) - currentDigit = currentDigit | 32; - } - encodedStr = encodedStr + base64FormatEncode(currentDigit); - } while (inValue > 0); - - return encodedStr; - } + if (sourceMapDataList) { + sourceMapDataList.push(sourceMap.getSourceMapData()); } - function recordSourceMapSpan(pos: number) { - const sourceLinePos = computeLineAndCharacterOfPosition(currentLineMap, pos); - - // Convert the location to be one-based. - sourceLinePos.line++; - sourceLinePos.character++; - - const emittedLine = writer.getLine(); - const emittedColumn = writer.getColumn(); - - // If this location wasn't recorded or the location in source is going backwards, record the span - if (!lastRecordedSourceMapSpan || - lastRecordedSourceMapSpan.emittedLine !== emittedLine || - lastRecordedSourceMapSpan.emittedColumn !== emittedColumn || - (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && - (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || - (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { - // Encode the last recordedSpan before assigning new - encodeLastRecordedSourceMapSpan(); - - // New span - lastRecordedSourceMapSpan = { - emittedLine: emittedLine, - emittedColumn: emittedColumn, - sourceLine: sourceLinePos.line, - sourceColumn: sourceLinePos.character, - nameIndex: getSourceMapNameIndex(), - sourceIndex: sourceMapSourceIndex - }; - } - else { - // Take the new pos instead since there is no change in emittedLine and column since last location - lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line; - lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character; - lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex; - } - } - - function recordEmitNodeStartSpan(node: Node) { - // Get the token pos after skipping to the token (ignoring the leading trivia) - recordSourceMapSpan(skipTrivia(currentText, node.pos)); - } - - function recordEmitNodeEndSpan(node: Node) { - recordSourceMapSpan(node.end); - } - - function writeTextWithSpanRecord(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) { - const tokenStartPos = ts.skipTrivia(currentText, startPos); - recordSourceMapSpan(tokenStartPos); - const tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn); - recordSourceMapSpan(tokenEndPos); - return tokenEndPos; - } - - function recordNewSourceFileStart(node: SourceFile) { - // Add the file to tsFilePaths - // If sourceroot option: Use the relative path corresponding to the common directory path - // otherwise source locations relative to map file location - const sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir; - - sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, - node.fileName, - host.getCurrentDirectory(), - host.getCanonicalFileName, - /*isAbsolutePathAnUrl*/ true)); - sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1; - - // The one that can be used from program to get the actual source file - sourceMapData.inputSourceFileNames.push(node.fileName); - - if (compilerOptions.inlineSources) { - if (!sourceMapData.sourceMapSourcesContent) { - sourceMapData.sourceMapSourcesContent = []; - } - sourceMapData.sourceMapSourcesContent.push(node.text); - } - } - - function recordScopeNameOfNode(node: Node, scopeName?: string) { - function recordScopeNameIndex(scopeNameIndex: number) { - sourceMapNameIndices.push(scopeNameIndex); - } - - function recordScopeNameStart(scopeName: string) { - let scopeNameIndex = -1; - if (scopeName) { - const parentIndex = getSourceMapNameIndex(); - if (parentIndex !== -1) { - // Child scopes are always shown with a dot (even if they have no name), - // unless it is a computed property. Then it is shown with brackets, - // but the brackets are included in the name. - const name = (node).name; - if (!name || name.kind !== SyntaxKind.ComputedPropertyName) { - scopeName = "." + scopeName; - } - scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; - } - - scopeNameIndex = getProperty(sourceMapNameIndexMap, scopeName); - if (scopeNameIndex === undefined) { - scopeNameIndex = sourceMapData.sourceMapNames.length; - sourceMapData.sourceMapNames.push(scopeName); - sourceMapNameIndexMap[scopeName] = scopeNameIndex; - } - } - recordScopeNameIndex(scopeNameIndex); - } - - if (scopeName) { - // The scope was already given a name use it - recordScopeNameStart(scopeName); - } - else if (node.kind === SyntaxKind.FunctionDeclaration || - node.kind === SyntaxKind.FunctionExpression || - node.kind === SyntaxKind.MethodDeclaration || - node.kind === SyntaxKind.MethodSignature || - node.kind === SyntaxKind.GetAccessor || - node.kind === SyntaxKind.SetAccessor || - node.kind === SyntaxKind.ModuleDeclaration || - node.kind === SyntaxKind.ClassDeclaration || - node.kind === SyntaxKind.EnumDeclaration) { - // Declaration and has associated name use it - if ((node).name) { - const name = (node).name; - // For computed property names, the text will include the brackets - scopeName = name.kind === SyntaxKind.ComputedPropertyName - ? getTextOfNode(name) - : ((node).name).text; - } - recordScopeNameStart(scopeName); - } - else { - // Block just use the name from upper level scope - recordScopeNameIndex(getSourceMapNameIndex()); - } - } - - function recordScopeNameEnd() { - sourceMapNameIndices.pop(); - }; - - function writeCommentRangeWithMap(currentText: string, currentLineMap: number[], writer: EmitTextWriter, comment: CommentRange, newLine: string) { - recordSourceMapSpan(comment.pos); - writeCommentRange(currentText, currentLineMap, writer, comment, newLine); - recordSourceMapSpan(comment.end); - } - - function serializeSourceMapContents(version: number, file: string, sourceRoot: string, sources: string[], names: string[], mappings: string, sourcesContent?: string[]) { - if (typeof JSON !== "undefined") { - const map: any = { - version, - file, - sourceRoot, - sources, - names, - mappings - }; - - if (sourcesContent !== undefined) { - map.sourcesContent = sourcesContent; - } - - return JSON.stringify(map); - } - - return "{\"version\":" + version + ",\"file\":\"" + escapeString(file) + "\",\"sourceRoot\":\"" + escapeString(sourceRoot) + "\",\"sources\":[" + serializeStringArray(sources) + "],\"names\":[" + serializeStringArray(names) + "],\"mappings\":\"" + escapeString(mappings) + "\" " + (sourcesContent !== undefined ? ",\"sourcesContent\":[" + serializeStringArray(sourcesContent) + "]" : "") + "}"; - - function serializeStringArray(list: string[]): string { - let output = ""; - for (let i = 0, n = list.length; i < n; i++) { - if (i) { - output += ","; - } - output += "\"" + escapeString(list[i]) + "\""; - } - return output; - } - } - - function writeJavaScriptAndSourceMapFile(emitOutput: string, jsFilePath: string, writeByteOrderMark: boolean) { - encodeLastRecordedSourceMapSpan(); - - const sourceMapText = serializeSourceMapContents( - 3, - sourceMapData.sourceMapFile, - sourceMapData.sourceMapSourceRoot, - sourceMapData.sourceMapSources, - sourceMapData.sourceMapNames, - sourceMapData.sourceMapMappings, - sourceMapData.sourceMapSourcesContent); - - sourceMapDataList.push(sourceMapData); - - let sourceMapUrl: string; - if (compilerOptions.inlineSourceMap) { - // Encode the sourceMap into the sourceMap url - const base64SourceMapText = convertToBase64(sourceMapText); - sourceMapData.jsSourceMappingURL = `data:application/json;base64,${base64SourceMapText}`; - } - else { - // Write source map file - writeFile(host, emitterDiagnostics, sourceMapData.sourceMapFilePath, sourceMapText, /*writeByteOrderMark*/ false); - } - sourceMapUrl = `//# sourceMappingURL=${sourceMapData.jsSourceMappingURL}`; - - // Write sourcemap url to the js file and write the js file - writeJavaScriptFile(emitOutput + sourceMapUrl, jsFilePath, writeByteOrderMark); - } - - // Initialize source map data - sourceMapData = { - sourceMapFilePath: sourceMapFilePath, - jsSourceMappingURL: !compilerOptions.inlineSourceMap ? getBaseFileName(normalizeSlashes(sourceMapFilePath)) : undefined, - sourceMapFile: getBaseFileName(normalizeSlashes(jsFilePath)), - sourceMapSourceRoot: compilerOptions.sourceRoot || "", - sourceMapSources: [], - inputSourceFileNames: [], - sourceMapNames: [], - sourceMapMappings: "", - sourceMapSourcesContent: undefined, - sourceMapDecodedMappings: [] - }; - - // Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the - // relative paths of the sources list in the sourcemap - sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot); - if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== CharacterCodes.slash) { - sourceMapData.sourceMapSourceRoot += directorySeparator; - } - - if (compilerOptions.mapRoot) { - sourceMapDir = normalizeSlashes(compilerOptions.mapRoot); - if (!isBundledEmit) { // emitting single module file - Debug.assert(sourceFiles.length === 1); - // For modules or multiple emit files the mapRoot will have directory structure like the sources - // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map - sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFiles[0], host, sourceMapDir)); - } - - if (!isRootedDiskPath(sourceMapDir) && !isUrl(sourceMapDir)) { - // The relative paths are relative to the common directory - sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir); - sourceMapData.jsSourceMappingURL = getRelativePathToDirectoryOrUrl( - getDirectoryPath(normalizePath(jsFilePath)), // get the relative sourceMapDir path based on jsFilePath - combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap - host.getCurrentDirectory(), - host.getCanonicalFileName, - /*isAbsolutePathAnUrl*/ true); - } - else { - sourceMapData.jsSourceMappingURL = combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL); - } - } - else { - sourceMapDir = getDirectoryPath(normalizePath(jsFilePath)); - } - - function emitNodeWithSourceMap(node: Node) { - if (node) { - if (nodeIsSynthesized(node)) { - return emitNodeWithoutSourceMap(node); - } - if (node.kind !== SyntaxKind.SourceFile) { - recordEmitNodeStartSpan(node); - emitNodeWithoutSourceMap(node); - recordEmitNodeEndSpan(node); - } - else { - recordNewSourceFileStart(node); - emitNodeWithoutSourceMap(node); - } - } - } - - function emitNodeWithCommentsAndWithSourcemap(node: Node) { - emitNodeConsideringCommentsOption(node, emitNodeWithSourceMap); - } - - writeEmittedFiles = writeJavaScriptAndSourceMapFile; - emit = emitNodeWithCommentsAndWithSourcemap; - emitStart = recordEmitNodeStartSpan; - emitEnd = recordEmitNodeEndSpan; - emitToken = writeTextWithSpanRecord; - scopeEmitStart = recordScopeNameOfNode; - scopeEmitEnd = recordScopeNameEnd; - writeComment = writeCommentRangeWithMap; - } - - function writeJavaScriptFile(emitOutput: string, jsFilePath: string, writeByteOrderMark: boolean) { writeFile(host, emitterDiagnostics, jsFilePath, emitOutput, writeByteOrderMark); } @@ -1139,7 +734,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } - function emitTokenText(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) { + /** Emit the text for the given token that comes after startPos + * This by default writes the text provided with the given tokenKind + * but if optional emitFn callback is provided the text is emitted using the callback instead of default text + * @param tokenKind the kind of the token to search and emit + * @param startPos the position in the source to start searching for the token + * @param emitFn if given will be invoked to emit the text instead of actual token emit */ + function emitToken(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) { + const tokenStartPos = skipTrivia(currentText, startPos); + emitPos(tokenStartPos); + const tokenString = tokenToString(tokenKind); if (emitFn) { emitFn(); @@ -1147,7 +751,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi else { write(tokenString); } - return startPos + tokenString.length; + + const tokenEndPos = tokenStartPos + tokenString.length; + emitPos(tokenEndPos); + return tokenEndPos; } function emitOptional(prefix: string, node: Node) { @@ -7735,6 +7342,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitLeadingComments(node.endOfFileToken); } + function emit(node: Node): void { + emitNodeConsideringCommentsOption(node, emitNodeWithSourceMap); + } + function emitNodeWithCommentsAndWithoutSourcemap(node: Node): void { emitNodeConsideringCommentsOption(node, emitNodeWithoutSourceMap); } @@ -7763,6 +7374,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } + function emitNodeWithSourceMap(node: Node): void { + if (node) { + emitStart(node); + emitNodeWithoutSourceMap(node); + emitEnd(node); + } + } + function emitNodeWithoutSourceMap(node: Node): void { if (node) { emitJavaScriptWorker(node); @@ -8155,6 +7774,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } + function writeComment(text: string, lineMap: number[], writer: EmitTextWriter, comment: CommentRange, newLine: string) { + emitPos(comment.pos); + writeCommentRange(text, lineMap, writer, comment, newLine); + emitPos(comment.end); + } + function emitShebang() { const shebang = getShebang(currentText); if (shebang) { diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 4289d910608..022d63fbe9d 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -425,6 +425,12 @@ namespace ts { /* @internal */ export function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number { + // Using ! with a greater than test is a fast way of testing the following conditions: + // pos === undefined || pos === null || isNaN(pos) || pos < 0; + if (!(pos >= 0)) { + return pos; + } + // Keep in sync with couldStartTrivia while (true) { const ch = text.charCodeAt(pos); @@ -567,12 +573,12 @@ namespace ts { } /** - * Extract comments from text prefixing the token closest following `pos`. + * Extract comments from text prefixing the token closest following `pos`. * The return value is an array containing a TextRange for each comment. * Single-line comment ranges include the beginning '//' characters but not the ending line break. * Multi - line comment ranges include the beginning '/* and ending '/' characters. * The return value is undefined if no comments were found. - * @param trailing + * @param trailing * If false, whitespace is skipped until the first line break and comments between that location * and the next token are returned. * If true, comments occurring between the given position and the next line break are returned. diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts new file mode 100644 index 00000000000..ffb1a7001a9 --- /dev/null +++ b/src/compiler/sourcemap.ts @@ -0,0 +1,416 @@ +/// + +/* @internal */ +namespace ts { + export interface SourceMapWriter { + getSourceMapData(): SourceMapData; + setSourceFile(sourceFile: SourceFile): void; + emitPos(pos: number): void; + emitStart(range: TextRange): void; + emitEnd(range: TextRange): void; + pushScope(scopeDeclaration: Node, scopeName?: string): void; + popScope(): void; + getText(): string; + getSourceMappingURL(): string; + initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean): void; + reset(): void; + } + + const nop = <(...args: any[]) => any>Function.prototype; + let nullSourceMapWriter: SourceMapWriter; + + export function getNullSourceMapWriter(): SourceMapWriter { + if (nullSourceMapWriter === undefined) { + nullSourceMapWriter = { + getSourceMapData: nop, + setSourceFile: nop, + emitStart: nop, + emitEnd: nop, + emitPos: nop, + pushScope: nop, + popScope: nop, + getText: nop, + getSourceMappingURL: nop, + initialize: nop, + reset: nop, + }; + } + + return nullSourceMapWriter; + } + + export function createSourceMapWriter(host: EmitHost, writer: EmitTextWriter): SourceMapWriter { + const compilerOptions = host.getCompilerOptions(); + let currentSourceFile: SourceFile; + let sourceMapDir: string; // The directory in which sourcemap will be + + // Current source map file and its index in the sources list + let sourceMapSourceIndex: number; + + // Names and its index map + let sourceMapNameIndexMap: Map; + let sourceMapNameIndices: number[]; + + // Last recorded and encoded spans + let lastRecordedSourceMapSpan: SourceMapSpan; + let lastEncodedSourceMapSpan: SourceMapSpan; + let lastEncodedNameIndex: number; + + // Source map data + let sourceMapData: SourceMapData; + + return { + getSourceMapData: () => sourceMapData, + setSourceFile, + emitPos, + emitStart, + emitEnd, + pushScope, + popScope, + getText, + getSourceMappingURL, + initialize, + reset, + }; + + function initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) { + if (sourceMapData) { + reset(); + } + + currentSourceFile = undefined; + + // Current source map file and its index in the sources list + sourceMapSourceIndex = -1; + + // Names and its index map + sourceMapNameIndexMap = {}; + sourceMapNameIndices = []; + + // Last recorded and encoded spans + lastRecordedSourceMapSpan = undefined; + lastEncodedSourceMapSpan = { + emittedLine: 1, + emittedColumn: 1, + sourceLine: 1, + sourceColumn: 1, + sourceIndex: 0 + }; + lastEncodedNameIndex = 0; + + // Initialize source map data + sourceMapData = { + sourceMapFilePath: sourceMapFilePath, + jsSourceMappingURL: !compilerOptions.inlineSourceMap ? getBaseFileName(normalizeSlashes(sourceMapFilePath)) : undefined, + sourceMapFile: getBaseFileName(normalizeSlashes(filePath)), + sourceMapSourceRoot: compilerOptions.sourceRoot || "", + sourceMapSources: [], + inputSourceFileNames: [], + sourceMapNames: [], + sourceMapMappings: "", + sourceMapSourcesContent: compilerOptions.inlineSources ? [] : undefined, + sourceMapDecodedMappings: [] + }; + + // Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the + // relative paths of the sources list in the sourcemap + sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot); + if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== CharacterCodes.slash) { + sourceMapData.sourceMapSourceRoot += directorySeparator; + } + + if (compilerOptions.mapRoot) { + sourceMapDir = normalizeSlashes(compilerOptions.mapRoot); + if (!isBundledEmit) { // emitting single module file + Debug.assert(sourceFiles.length === 1); + // For modules or multiple emit files the mapRoot will have directory structure like the sources + // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map + sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFiles[0], host, sourceMapDir)); + } + + if (!isRootedDiskPath(sourceMapDir) && !isUrl(sourceMapDir)) { + // The relative paths are relative to the common directory + sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir); + sourceMapData.jsSourceMappingURL = getRelativePathToDirectoryOrUrl( + getDirectoryPath(normalizePath(filePath)), // get the relative sourceMapDir path based on jsFilePath + combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap + host.getCurrentDirectory(), + host.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ true); + } + else { + sourceMapData.jsSourceMappingURL = combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL); + } + } + else { + sourceMapDir = getDirectoryPath(normalizePath(filePath)); + } + } + + function reset() { + currentSourceFile = undefined; + sourceMapDir = undefined; + sourceMapSourceIndex = undefined; + sourceMapNameIndexMap = undefined; + sourceMapNameIndices = undefined; + lastRecordedSourceMapSpan = undefined; + lastEncodedSourceMapSpan = undefined; + lastEncodedNameIndex = undefined; + sourceMapData = undefined; + } + + function getSourceMapNameIndex() { + return sourceMapNameIndices.length ? lastOrUndefined(sourceMapNameIndices) : -1; + } + + // Encoding for sourcemap span + function encodeLastRecordedSourceMapSpan() { + if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) { + return; + } + + let prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; + // Line/Comma delimiters + if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) { + // Emit comma to separate the entry + if (sourceMapData.sourceMapMappings) { + sourceMapData.sourceMapMappings += ","; + } + } + else { + // Emit line delimiters + for (let encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) { + sourceMapData.sourceMapMappings += ";"; + } + prevEncodedEmittedColumn = 1; + } + + // 1. Relative Column 0 based + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn); + + // 2. Relative sourceIndex + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex); + + // 3. Relative sourceLine 0 based + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine); + + // 4. Relative sourceColumn 0 based + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn); + + // 5. Relative namePosition 0 based + if (lastRecordedSourceMapSpan.nameIndex >= 0) { + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex); + lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex; + } + + lastEncodedSourceMapSpan = lastRecordedSourceMapSpan; + sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan); + } + + function emitPos(pos: number) { + if (pos === -1) { + return; + } + + const sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos); + + // Convert the location to be one-based. + sourceLinePos.line++; + sourceLinePos.character++; + + const emittedLine = writer.getLine(); + const emittedColumn = writer.getColumn(); + + // If this location wasn't recorded or the location in source is going backwards, record the span + if (!lastRecordedSourceMapSpan || + lastRecordedSourceMapSpan.emittedLine !== emittedLine || + lastRecordedSourceMapSpan.emittedColumn !== emittedColumn || + (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && + (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || + (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { + + // Encode the last recordedSpan before assigning new + encodeLastRecordedSourceMapSpan(); + + // New span + lastRecordedSourceMapSpan = { + emittedLine: emittedLine, + emittedColumn: emittedColumn, + sourceLine: sourceLinePos.line, + sourceColumn: sourceLinePos.character, + nameIndex: getSourceMapNameIndex(), + sourceIndex: sourceMapSourceIndex + }; + } + else { + // Take the new pos instead since there is no change in emittedLine and column since last location + lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line; + lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character; + lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex; + } + } + + function emitStart(range: TextRange) { + emitPos(range.pos !== -1 ? skipTrivia(currentSourceFile.text, range.pos) : -1); + } + + function emitEnd(range: TextRange) { + emitPos(range.end); + } + + function setSourceFile(sourceFile: SourceFile) { + currentSourceFile = sourceFile; + + // Add the file to tsFilePaths + // If sourceroot option: Use the relative path corresponding to the common directory path + // otherwise source locations relative to map file location + const sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir; + + const source = getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, + currentSourceFile.fileName, + host.getCurrentDirectory(), + host.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ true); + + sourceMapSourceIndex = indexOf(sourceMapData.sourceMapSources, source); + if (sourceMapSourceIndex === -1) { + sourceMapSourceIndex = sourceMapData.sourceMapSources.length; + sourceMapData.sourceMapSources.push(source); + + // The one that can be used from program to get the actual source file + sourceMapData.inputSourceFileNames.push(sourceFile.fileName); + + if (compilerOptions.inlineSources) { + sourceMapData.sourceMapSourcesContent.push(sourceFile.text); + } + } + } + + function recordScopeNameIndex(scopeNameIndex: number) { + sourceMapNameIndices.push(scopeNameIndex); + } + + function recordScopeNameStart(scopeDeclaration: Node, scopeName: string) { + let scopeNameIndex = -1; + if (scopeName) { + const parentIndex = getSourceMapNameIndex(); + if (parentIndex !== -1) { + // Child scopes are always shown with a dot (even if they have no name), + // unless it is a computed property. Then it is shown with brackets, + // but the brackets are included in the name. + const name = (scopeDeclaration).name; + if (!name || name.kind !== SyntaxKind.ComputedPropertyName) { + scopeName = "." + scopeName; + } + scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; + } + + scopeNameIndex = getProperty(sourceMapNameIndexMap, scopeName); + if (scopeNameIndex === undefined) { + scopeNameIndex = sourceMapData.sourceMapNames.length; + sourceMapData.sourceMapNames.push(scopeName); + sourceMapNameIndexMap[scopeName] = scopeNameIndex; + } + } + recordScopeNameIndex(scopeNameIndex); + } + + function pushScope(scopeDeclaration: Node, scopeName?: string) { + if (scopeName) { + // The scope was already given a name use it + recordScopeNameStart(scopeDeclaration, scopeName); + } + else if (scopeDeclaration.kind === SyntaxKind.FunctionDeclaration || + scopeDeclaration.kind === SyntaxKind.FunctionExpression || + scopeDeclaration.kind === SyntaxKind.MethodDeclaration || + scopeDeclaration.kind === SyntaxKind.MethodSignature || + scopeDeclaration.kind === SyntaxKind.GetAccessor || + scopeDeclaration.kind === SyntaxKind.SetAccessor || + scopeDeclaration.kind === SyntaxKind.ModuleDeclaration || + scopeDeclaration.kind === SyntaxKind.ClassDeclaration || + scopeDeclaration.kind === SyntaxKind.EnumDeclaration) { + // Declaration and has associated name use it + if ((scopeDeclaration).name) { + const name = (scopeDeclaration).name; + // For computed property names, the text will include the brackets + scopeName = name.kind === SyntaxKind.ComputedPropertyName + ? getTextOfNode(name) + : ((scopeDeclaration).name).text; + } + + recordScopeNameStart(scopeDeclaration, scopeName); + } + else { + // Block just use the name from upper level scope + recordScopeNameIndex(getSourceMapNameIndex()); + } + } + + function popScope() { + sourceMapNameIndices.pop(); + } + + function getText() { + encodeLastRecordedSourceMapSpan(); + + return stringify({ + version: 3, + file: sourceMapData.sourceMapFile, + sourceRoot: sourceMapData.sourceMapSourceRoot, + sources: sourceMapData.sourceMapSources, + names: sourceMapData.sourceMapNames, + mappings: sourceMapData.sourceMapMappings, + sourcesContent: sourceMapData.sourceMapSourcesContent, + }); + } + + function getSourceMappingURL() { + if (compilerOptions.inlineSourceMap) { + // Encode the sourceMap into the sourceMap url + const base64SourceMapText = convertToBase64(getText()); + return sourceMapData.jsSourceMappingURL = `data:application/json;base64,${base64SourceMapText}`; + } + else { + return sourceMapData.jsSourceMappingURL; + } + } + } + + const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + function base64FormatEncode(inValue: number) { + if (inValue < 64) { + return base64Chars.charAt(inValue); + } + + throw TypeError(inValue + ": not a 64 based value"); + } + + function base64VLQFormatEncode(inValue: number) { + // Add a new least significant bit that has the sign of the value. + // if negative number the least significant bit that gets added to the number has value 1 + // else least significant bit value that gets added is 0 + // eg. -1 changes to binary : 01 [1] => 3 + // +1 changes to binary : 01 [0] => 2 + if (inValue < 0) { + inValue = ((-inValue) << 1) + 1; + } + else { + inValue = inValue << 1; + } + + // Encode 5 bits at a time starting from least significant bits + let encodedStr = ""; + do { + let currentDigit = inValue & 31; // 11111 + inValue = inValue >> 5; + if (inValue > 0) { + // There are still more digits to decode, set the msb (6th bit) + currentDigit = currentDigit | 32; + } + encodedStr = encodedStr + base64FormatEncode(currentDigit); + } while (inValue > 0); + + return encodedStr; + } +} \ No newline at end of file diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 1884cee1516..12b9c404c5d 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2414,6 +2414,27 @@ namespace ts { return output; } + export const stringify: (value: any) => string = JSON && JSON.stringify ? JSON.stringify : function stringify(value: any): string { + /* tslint:disable:no-null */ + return value == null ? "null" + : typeof value === "string" ? `"${escapeString(value)}"` + : typeof value === "number" ? String(value) + : typeof value === "boolean" ? value ? "true" : "false" + : isArray(value) ? `[${reduceLeft(value, stringifyElement, "")}]` + : typeof value === "object" ? `{${reduceProperties(value, stringifyProperty, "")}}` + : "null"; + /* tslint:enable:no-null */ + }; + + function stringifyElement(memo: string, value: any) { + return (memo ? memo + "," : memo) + stringify(value); + } + + function stringifyProperty(memo: string, value: any, key: string) { + return value === undefined ? memo + : (memo ? memo + "," : memo) + `"${escapeString(key)}":${stringify(value)}`; + } + const base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; /** From aa5e57668ffad5259ab0b61e32cc8c5028f608cb Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Nov 2015 16:26:57 -0800 Subject: [PATCH 32/51] minor tweak to null handling in stringify --- src/compiler/utilities.ts | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 12b9c404c5d..28d8cba3234 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2415,24 +2415,28 @@ namespace ts { } export const stringify: (value: any) => string = JSON && JSON.stringify ? JSON.stringify : function stringify(value: any): string { + return value === undefined ? undefined : stringifyValue(value); + }; + + function stringifyValue(value: any): string { /* tslint:disable:no-null */ - return value == null ? "null" + return value === null ? "null" // explicit test for `null` as `typeof null` is "object" : typeof value === "string" ? `"${escapeString(value)}"` : typeof value === "number" ? String(value) : typeof value === "boolean" ? value ? "true" : "false" : isArray(value) ? `[${reduceLeft(value, stringifyElement, "")}]` : typeof value === "object" ? `{${reduceProperties(value, stringifyProperty, "")}}` - : "null"; + : /*fallback*/ "null"; /* tslint:enable:no-null */ - }; + } function stringifyElement(memo: string, value: any) { - return (memo ? memo + "," : memo) + stringify(value); + return (memo ? memo + "," : memo) + stringifyValue(value); } function stringifyProperty(memo: string, value: any, key: string) { - return value === undefined ? memo - : (memo ? memo + "," : memo) + `"${escapeString(key)}":${stringify(value)}`; + return value === undefined || typeof value === "function" ? memo + : (memo ? memo + "," : memo) + `"${escapeString(key)}":${stringifyValue(value)}`; } const base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; From fd51ebf0fd965acc49ab01dc7eaf03490ff7d91f Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Nov 2015 16:59:55 -0800 Subject: [PATCH 33/51] Minor stringify cleanup, added cycle detection for AssertionLevel.Aggresive only. --- src/compiler/utilities.ts | 60 +++++++++++++++++++++++++++++++++------ 1 file changed, 52 insertions(+), 8 deletions(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 28d8cba3234..2034a2d276d 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2414,26 +2414,70 @@ namespace ts { return output; } + /** + * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph + * as the fallback implementation does not check for circular references by default. + */ export const stringify: (value: any) => string = JSON && JSON.stringify ? JSON.stringify : function stringify(value: any): string { + if (Debug.shouldAssert(AssertionLevel.Aggressive)) { + Debug.assert(!hasCycles(value, []), "Detected circular reference before serializing object graph."); + } + return value === undefined ? undefined : stringifyValue(value); }; - function stringifyValue(value: any): string { + function hasCycles(value: any, stack: any[]) { /* tslint:disable:no-null */ - return value === null ? "null" // explicit test for `null` as `typeof null` is "object" - : typeof value === "string" ? `"${escapeString(value)}"` - : typeof value === "number" ? String(value) - : typeof value === "boolean" ? value ? "true" : "false" - : isArray(value) ? `[${reduceLeft(value, stringifyElement, "")}]` - : typeof value === "object" ? `{${reduceProperties(value, stringifyProperty, "")}}` - : /*fallback*/ "null"; + if (typeof value !== "object" || value === null) { + return false; + } /* tslint:enable:no-null */ + + if (stack.lastIndexOf(value) !== -1) { + return true; + } + + stack.push(value); + + if (isArray(value)) { + for (const entry of value) { + if (hasCycles(entry, stack)) { + return true; + } + } + } + else { + for (const key in value) { + if (hasProperty(value, key) && hasCycles(value[key], stack)) { + return true; + } + } + } + + stack.pop(); + return false; + } + + function stringifyValue(value: any): string { + return typeof value === "string" ? `"${escapeString(value)}"` + : typeof value === "number" ? isFinite(value) ? String(value) : "null" + : typeof value === "boolean" ? value ? "true" : "false" + : typeof value === "object" ? isArray(value) ? stringifyArray(value) : stringifyObject(value) + : /*fallback*/ "null"; + } + + function stringifyArray(value: any) { + return `[${reduceLeft(value, stringifyElement, "")}]`; } function stringifyElement(memo: string, value: any) { return (memo ? memo + "," : memo) + stringifyValue(value); } + function stringifyObject(value: any) { + return value ? `{${reduceProperties(value, stringifyProperty, "")}}` : "null"; + } + function stringifyProperty(memo: string, value: any, key: string) { return value === undefined || typeof value === "function" ? memo : (memo ? memo + "," : memo) + `"${escapeString(key)}":${stringifyValue(value)}`; From 0ad2efcd61a1dbdc548d74dcb16717dbed9dfef5 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Nov 2015 17:00:27 -0800 Subject: [PATCH 34/51] removed typeof check for isArray --- src/compiler/core.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 7590f8c73cd..cae7bd82103 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -380,7 +380,7 @@ namespace ts { * Tests whether a value is an array. */ export function isArray(value: any): value is any[] { - return Array.isArray ? Array.isArray(value) : typeof value === "object" && value instanceof Array; + return Array.isArray ? Array.isArray(value) : value instanceof Array; } export function memoize(callback: () => T): () => T { From d88186bc1199e960122a09aac7a0fa2d255a61a8 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Nov 2015 17:06:17 -0800 Subject: [PATCH 35/51] Removed isArray branch in checkCycles as it was unnecessary --- src/compiler/utilities.ts | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 2034a2d276d..e649edf2115 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2439,18 +2439,9 @@ namespace ts { stack.push(value); - if (isArray(value)) { - for (const entry of value) { - if (hasCycles(entry, stack)) { - return true; - } - } - } - else { - for (const key in value) { - if (hasProperty(value, key) && hasCycles(value[key], stack)) { - return true; - } + for (const key in value) { + if (hasProperty(value, key) && hasCycles(value[key], stack)) { + return true; } } From 7ff4238f93d760a953b525c1a6ee1daca21475a8 Mon Sep 17 00:00:00 2001 From: Yui T Date: Tue, 24 Nov 2015 17:44:10 -0800 Subject: [PATCH 36/51] Fix crushing of getting signatureDeclaration when we are not in function declaration --- src/services/services.ts | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 8d66b5c7b8a..54c76a063b2 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4247,24 +4247,22 @@ namespace ts { } else { // Method/function type parameter - let container = getContainingFunction(location); - if (container) { - let signatureDeclaration = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter).parent; - let signature = typeChecker.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === SyntaxKind.ConstructSignature) { + let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter).parent; + if (declaration && isFunctionLikeKind(declaration.kind)) { + let signature = typeChecker.getSignatureFromDeclaration(declaration); + if (declaration.kind === SyntaxKind.ConstructSignature) { displayParts.push(keywordPart(SyntaxKind.NewKeyword)); displayParts.push(spacePart()); } - else if (signatureDeclaration.kind !== SyntaxKind.CallSignature && signatureDeclaration.name) { - addFullSymbolName(signatureDeclaration.symbol); + else if (declaration.kind !== SyntaxKind.CallSignature && (declaration).name) { + addFullSymbolName(declaration.symbol); } addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, TypeFormatFlags.WriteTypeArgumentsOfSignature)); } else { - // Type aliash type parameter + // Type alias type parameter // For example // type list = T[]; // Both T will go through same code path - let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter).parent; displayParts.push(keywordPart(SyntaxKind.TypeKeyword)); displayParts.push(spacePart()); addFullSymbolName(declaration.symbol); From 81fdc4384f5a9582d010414884066a4d5172c974 Mon Sep 17 00:00:00 2001 From: Yui T Date: Tue, 24 Nov 2015 17:50:00 -0800 Subject: [PATCH 37/51] Add fourslash tests --- ...mpletionListInTypeParameterOfTypeAlias3.ts | 13 ++++++ ...sTypeParameterInFunctionLikeInTypeAlias.ts | 22 ++++++++++ ...nfoDisplayPartsTypeParameterInTypeAlias.ts | 3 -- ...sTypeParameterOfFunctionLikeInTypeAlias.ts | 41 +++++++++++++++++++ 4 files changed, 76 insertions(+), 3 deletions(-) create mode 100644 tests/cases/fourslash/completionListInTypeParameterOfTypeAlias3.ts create mode 100644 tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.ts create mode 100644 tests/cases/fourslash/quickInfoDisplayPartsTypeParameterOfFunctionLikeInTypeAlias.ts diff --git a/tests/cases/fourslash/completionListInTypeParameterOfTypeAlias3.ts b/tests/cases/fourslash/completionListInTypeParameterOfTypeAlias3.ts new file mode 100644 index 00000000000..59cceda2aad --- /dev/null +++ b/tests/cases/fourslash/completionListInTypeParameterOfTypeAlias3.ts @@ -0,0 +1,13 @@ +/// + +//// type constructorType = new + +//// type MixinCtor = new () => /*0*/A & { constructor: MixinCtor }; +//// type MixinCtor = new () => A & { constructor: { constructor: MixinCtor } }; + +let typeAliashDisplayParts = [{ text: "type", kind: "keyword" }, { text: " ", kind: "space" }, { text: "MixinCtor", kind: "aliasName" }, + { text: "<", kind: "punctuation" }, { text: "A", kind: "typeParameterName" }, { text: ">", kind: "punctuation" }]; + +let typeParameterDisplayParts = [{ text: "(", kind: "punctuation" }, { text: "type parameter", kind: "text" }, { text: ")", kind: "punctuation" }, { text: " ", kind: "space" }, + { text: "A", kind: "typeParameterName" }, { text: " ", kind: "space" }, { text: "in", kind: "keyword" }, { text: " ", kind: "space" }]; + +goTo.marker('0'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("0").position, length: "A".length }, + typeParameterDisplayParts.concat(typeAliashDisplayParts), []); + +goTo.marker('1'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("1").position, length: "A".length }, + typeParameterDisplayParts.concat(typeAliashDisplayParts), []);; + +goTo.marker('2'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("2").position, length: "A".length }, + typeParameterDisplayParts.concat(typeAliashDisplayParts), []); \ No newline at end of file diff --git a/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts b/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts index b6a10e086c2..5dbcfa93d78 100644 --- a/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts +++ b/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts @@ -3,9 +3,6 @@ ////type /*0*/List = /*2*/T[] ////type /*3*/List2 = /*5*/T[]; -type List2 = T[]; - -type L = T[] let typeAliashDisplayParts = [{ text: "type", kind: "keyword" }, { text: " ", kind: "space" }, { text: "List", kind: "aliasName" }, { text: "<", kind: "punctuation" }, { text: "T", kind: "typeParameterName" }, { text: ">", kind: "punctuation" }]; diff --git a/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterOfFunctionLikeInTypeAlias.ts b/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterOfFunctionLikeInTypeAlias.ts new file mode 100644 index 00000000000..917358fde57 --- /dev/null +++ b/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterOfFunctionLikeInTypeAlias.ts @@ -0,0 +1,41 @@ +/// + +//// type jamming = new () => jamming; +//// type jamming = (new () => jamming) & { constructor: /*2*/A }; +//// type jamming = new () => jamming & { constructor: /*3*/A }; + +let typeAliashDisplayParts = [{ text: "type", kind: "keyword" }, { text: " ", kind: "space" }, { text: "jamming", kind: "aliasName" }, + { text: "<", kind: "punctuation" }, { text: "A", kind: "typeParameterName" }, { text: ">", kind: "punctuation" }]; + +let typeParameterDisplayParts = [{ text: "(", kind: "punctuation" }, { text: "type parameter", kind: "text" }, { text: ")", kind: "punctuation" }, { text: " ", kind: "space" }, + { text: "A", kind: "typeParameterName" }, { text: " ", kind: "space" }, { text: "in", kind: "keyword" }, { text: " ", kind: "space" }]; + +let constructorTypeDisplayParts = [{ text: "<", kind: "punctuation" }, { text: "A", kind: "typeParameterName" }, { text: ">", kind: "punctuation" }, + { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, + { text: "new", kind: "keyword" }, { "text": " ", kind: "space" }, { text: "<", kind: "punctuation" }, { text: "A", kind: "typeParameterName" }, + { text: ">", kind: "punctuation" }, { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, {"text": " ", kind: "space" }, + { text: "=>", kind: "punctuation" }, { "text": " ", kind: "space" }, { text: "jamming", kind: "aliasName" }]; + +let constructorTypeWithLongReturnTypeDisplayParts = [{ "text": "<", kind: "punctuation" }, { "text": "A", kind: "typeParameterName" }, { "text": ">", kind: "punctuation" }, + { "text": "(", kind: "punctuation" }, { "text": ")", kind: "punctuation" }, { "text": ":", kind: "punctuation" }, { "text": " ", kind: "space" }, { "text": "(", kind: "punctuation" }, + { "text": "new", kind: "keyword" }, { "text": " ", kind: "space" }, { "text": "<", kind: "punctuation" }, { "text": "A", kind: "typeParameterName" }, { "text": ">", kind: "punctuation" }, + { "text": "(", kind: "punctuation" }, { "text": ")", kind: "punctuation" }, { "text": " ", kind: "space" }, { "text": "=>", kind: "punctuation" }, { "text": " ", kind: "space" }, + { "text": "jamming", kind: "aliasName" }, { "text": ")", kind: "punctuation" }, { "text": " ", kind: "space" }, { "text": "&", kind: "punctuation" }, { "text": " ", kind: "space" }, + { "text": "{", kind: "punctuation" }, { "text": "\n", kind: "lineBreak" }, { "text": " ", kind: "space" }, { "text": "constructor", kind: "propertyName" }, { "text": ":", kind: "punctuation" }, + { "text": " ", kind: "space" }, { "text": "A", kind: "typeParameterName" }, {"text":";", kind: "punctuation" }, {"text":"\n", kind: "lineBreak" }, {"text":"}", kind: "punctuation" }]; + +goTo.marker('0'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("0").position, length: "A".length }, + typeParameterDisplayParts.concat(constructorTypeDisplayParts), []); + +goTo.marker('1'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("1").position, length: "A".length }, + typeParameterDisplayParts.concat(constructorTypeDisplayParts), []); + +goTo.marker('2'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("2").position, length: "A".length }, + typeParameterDisplayParts.concat(typeAliashDisplayParts), []); + +goTo.marker('3'); +verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("3").position, length: "A".length }, + typeParameterDisplayParts.concat(constructorTypeWithLongReturnTypeDisplayParts), []); \ No newline at end of file From 8702cc4215d6ab0fb7d4f300d823e6fb2c6280d1 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 24 Nov 2015 18:01:47 -0800 Subject: [PATCH 38/51] Renamed functions, fixed signature, removed TODO. --- src/compiler/checker.ts | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c6ff38888a2..2ae303af37a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4527,7 +4527,7 @@ namespace ts { return links.resolvedType; } - function getStringLiteralType(text: string): StringLiteralType { + function getStringLiteralTypeForText(text: string): StringLiteralType { if (hasProperty(stringLiteralTypes, text)) { return stringLiteralTypes[text]; } @@ -4537,10 +4537,10 @@ namespace ts { return type; } - function getTypeFromStringLiteral(node: StringLiteral | StringLiteralTypeNode): Type { + function getTypeFromStringLiteralTypeNode(node: StringLiteralTypeNode): Type { const links = getNodeLinks(node); if (!links.resolvedType) { - links.resolvedType = getStringLiteralType(node.text); + links.resolvedType = getStringLiteralTypeForText(node.text); } return links.resolvedType; } @@ -4583,7 +4583,7 @@ namespace ts { case SyntaxKind.ThisType: return getTypeFromThisTypeNode(node); case SyntaxKind.StringLiteralType: - return getTypeFromStringLiteral(node); + return getTypeFromStringLiteralTypeNode(node); case SyntaxKind.TypeReference: return getTypeFromTypeReference(node); case SyntaxKind.TypePredicate: @@ -8790,7 +8790,7 @@ namespace ts { // for the argument. In that case, we should check the argument. if (argType === undefined) { argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors - ? getStringLiteralType((arg).text) + ? getStringLiteralTypeForText((arg).text) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); } @@ -8985,7 +8985,7 @@ namespace ts { case SyntaxKind.Identifier: case SyntaxKind.NumericLiteral: case SyntaxKind.StringLiteral: - return getStringLiteralType((element.name).text); + return getStringLiteralTypeForText((element.name).text); case SyntaxKind.ComputedPropertyName: const nameType = checkComputedPropertyName(element.name); @@ -10607,8 +10607,7 @@ namespace ts { function checkStringLiteralExpression(node: StringLiteral): Type { const contextualType = getContextualType(node); if (contextualType && contextualTypeIsStringLiteralType(contextualType)) { - // TODO (drosen): Consider using getTypeFromStringLiteral instead - return getStringLiteralType(node.text); + return getStringLiteralTypeForText(node.text); } return stringType; From c5a2969255e7b1c1d45c3b6bb276455e6992ed8d Mon Sep 17 00:00:00 2001 From: Yui T Date: Wed, 25 Nov 2015 11:41:51 -0800 Subject: [PATCH 39/51] check for null --- src/services/services.ts | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 54c76a063b2..b53ff02e195 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4247,26 +4247,30 @@ namespace ts { } else { // Method/function type parameter - let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter).parent; - if (declaration && isFunctionLikeKind(declaration.kind)) { - let signature = typeChecker.getSignatureFromDeclaration(declaration); - if (declaration.kind === SyntaxKind.ConstructSignature) { - displayParts.push(keywordPart(SyntaxKind.NewKeyword)); + let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter); + declaration = declaration ? declaration.parent : undefined; + + if (declaration) { + if (isFunctionLikeKind(declaration.kind)) { + let signature = typeChecker.getSignatureFromDeclaration(declaration); + if (declaration.kind === SyntaxKind.ConstructSignature) { + displayParts.push(keywordPart(SyntaxKind.NewKeyword)); + displayParts.push(spacePart()); + } + else if (declaration.kind !== SyntaxKind.CallSignature && (declaration).name) { + addFullSymbolName(declaration.symbol); + } + addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, TypeFormatFlags.WriteTypeArgumentsOfSignature)); + } + else { + // Type alias type parameter + // For example + // type list = T[]; // Both T will go through same code path + displayParts.push(keywordPart(SyntaxKind.TypeKeyword)); displayParts.push(spacePart()); - } - else if (declaration.kind !== SyntaxKind.CallSignature && (declaration).name) { addFullSymbolName(declaration.symbol); + writeTypeParametersOfSymbol(declaration.symbol, sourceFile); } - addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, TypeFormatFlags.WriteTypeArgumentsOfSignature)); - } - else { - // Type alias type parameter - // For example - // type list = T[]; // Both T will go through same code path - displayParts.push(keywordPart(SyntaxKind.TypeKeyword)); - displayParts.push(spacePart()); - addFullSymbolName(declaration.symbol); - writeTypeParametersOfSymbol(declaration.symbol, sourceFile); } } } From b33eff1143aab72b63e92da3b8ded8026a86f263 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 25 Nov 2015 12:47:32 -0800 Subject: [PATCH 40/51] PR feedback --- src/compiler/emitter.ts | 34 +++++++++++++++++----------------- src/compiler/sourcemap.ts | 22 +++++++++++----------- src/compiler/utilities.ts | 25 +++++++++++++++++-------- 3 files changed, 45 insertions(+), 36 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index ac7aa0f00dc..620abbe156d 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -460,7 +460,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi const { write, writeTextOfNode, writeLine, increaseIndent, decreaseIndent } = writer; const sourceMap = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? createSourceMapWriter(host, writer) : getNullSourceMapWriter(); - const { setSourceFile, emitStart, emitEnd, emitPos, pushScope: scopeEmitStart, popScope: scopeEmitEnd } = sourceMap; + const { setSourceFile, emitStart, emitEnd, emitPos, pushScope, popScope } = sourceMap; let currentSourceFile: SourceFile; let currentText: string; @@ -2692,7 +2692,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitToken(SyntaxKind.OpenBraceToken, node.pos); increaseIndent(); - scopeEmitStart(node.parent); + pushScope(node.parent); if (node.kind === SyntaxKind.ModuleBlock) { Debug.assert(node.parent.kind === SyntaxKind.ModuleDeclaration); emitCaptureThisForNodeIfNecessary(node.parent); @@ -2704,7 +2704,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi decreaseIndent(); writeLine(); emitToken(SyntaxKind.CloseBraceToken, node.statements.end); - scopeEmitEnd(); + popScope(); } function emitEmbeddedStatement(node: Node) { @@ -4549,7 +4549,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function emitDownLevelExpressionFunctionBody(node: FunctionLikeDeclaration, body: Expression) { write(" {"); - scopeEmitStart(node); + pushScope(node); increaseIndent(); const outPos = writer.getTextPos(); @@ -4590,12 +4590,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("}"); emitEnd(node.body); - scopeEmitEnd(); + popScope(); } function emitBlockFunctionBody(node: FunctionLikeDeclaration, body: Block) { write(" {"); - scopeEmitStart(node); + pushScope(node); const initialTextPos = writer.getTextPos(); @@ -4630,7 +4630,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } emitToken(SyntaxKind.CloseBraceToken, body.statements.end); - scopeEmitEnd(); + popScope(); } function findInitialSuperCall(ctor: ConstructorDeclaration): ExpressionStatement { @@ -4916,7 +4916,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi let startIndex = 0; write(" {"); - scopeEmitStart(node, "constructor"); + pushScope(node, "constructor"); increaseIndent(); if (ctor) { // Emit all the directive prologues (like "use strict"). These have to come before @@ -4966,7 +4966,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } decreaseIndent(); emitToken(SyntaxKind.CloseBraceToken, ctor ? (ctor.body).statements.end : node.members.end); - scopeEmitEnd(); + popScope(); emitEnd(ctor || node); if (ctor) { emitTrailingComments(ctor); @@ -5103,14 +5103,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(" {"); increaseIndent(); - scopeEmitStart(node); + pushScope(node); writeLine(); emitConstructor(node, baseTypeNode); emitMemberFunctionsForES6AndHigher(node); decreaseIndent(); writeLine(); emitToken(SyntaxKind.CloseBraceToken, node.members.end); - scopeEmitEnd(); + popScope(); // TODO(rbuckton): Need to go back to `let _a = class C {}` approach, removing the defineProperty call for now. @@ -5197,7 +5197,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi tempParameters = undefined; computedPropertyNamesToGeneratedNames = undefined; increaseIndent(); - scopeEmitStart(node); + pushScope(node); if (baseTypeNode) { writeLine(); emitStart(baseTypeNode); @@ -5230,7 +5230,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi decreaseIndent(); writeLine(); emitToken(SyntaxKind.CloseBraceToken, node.members.end); - scopeEmitEnd(); + popScope(); emitStart(node); write(")("); if (baseTypeNode) { @@ -5792,12 +5792,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitEnd(node.name); write(") {"); increaseIndent(); - scopeEmitStart(node); + pushScope(node); emitLines(node.members); decreaseIndent(); writeLine(); emitToken(SyntaxKind.CloseBraceToken, node.members.end); - scopeEmitEnd(); + popScope(); write(")("); emitModuleMemberName(node); write(" || ("); @@ -5921,7 +5921,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi else { write("{"); increaseIndent(); - scopeEmitStart(node); + pushScope(node); emitCaptureThisForNodeIfNecessary(node); writeLine(); emit(node.body); @@ -5929,7 +5929,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi writeLine(); const moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body; emitToken(SyntaxKind.CloseBraceToken, moduleBlock.statements.end); - scopeEmitEnd(); + popScope(); } write(")("); // write moduleDecl = containingModule.m only if it is not exported es6 module member diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts index ffb1a7001a9..d29e3213588 100644 --- a/src/compiler/sourcemap.ts +++ b/src/compiler/sourcemap.ts @@ -22,17 +22,17 @@ namespace ts { export function getNullSourceMapWriter(): SourceMapWriter { if (nullSourceMapWriter === undefined) { nullSourceMapWriter = { - getSourceMapData: nop, - setSourceFile: nop, - emitStart: nop, - emitEnd: nop, - emitPos: nop, - pushScope: nop, - popScope: nop, - getText: nop, - getSourceMappingURL: nop, - initialize: nop, - reset: nop, + getSourceMapData(): SourceMapData { return undefined; }, + setSourceFile(sourceFile: SourceFile): void { }, + emitStart(range: TextRange): void { }, + emitEnd(range: TextRange): void { }, + emitPos(pos: number): void { }, + pushScope(scopeDeclaration: Node, scopeName?: string): void { }, + popScope(): void { }, + getText(): string { return undefined; }, + getSourceMappingURL(): string { return undefined; }, + initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean): void { }, + reset(): void { }, }; } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e649edf2115..e9175a5d5ef 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2418,14 +2418,10 @@ namespace ts { * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph * as the fallback implementation does not check for circular references by default. */ - export const stringify: (value: any) => string = JSON && JSON.stringify ? JSON.stringify : function stringify(value: any): string { - if (Debug.shouldAssert(AssertionLevel.Aggressive)) { - Debug.assert(!hasCycles(value, []), "Detected circular reference before serializing object graph."); - } - - return value === undefined ? undefined : stringifyValue(value); - }; - + export const stringify: (value: any) => string = JSON && JSON.stringify + ? JSON.stringify + : stringifyFallback; + function hasCycles(value: any, stack: any[]) { /* tslint:disable:no-null */ if (typeof value !== "object" || value === null) { @@ -2449,6 +2445,19 @@ namespace ts { return false; } + /** + * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph + * as the fallback implementation does not check for circular references by default. + */ + function stringifyFallback(value: any): string { + if (Debug.shouldAssert(AssertionLevel.Aggressive)) { + Debug.assert(!hasCycles(value, []), "Detected circular reference before serializing object graph."); + } + + // JSON.stringify returns `undefined` here, instead of the string "undefined". + return value === undefined ? undefined : stringifyValue(value); + } + function stringifyValue(value: any): string { return typeof value === "string" ? `"${escapeString(value)}"` : typeof value === "number" ? isFinite(value) ? String(value) : "null" From 6bc2c069a6e40e0d903070d5b14460be68296c53 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 25 Nov 2015 13:53:30 -0800 Subject: [PATCH 41/51] Missed linter error. --- src/compiler/utilities.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e9175a5d5ef..47941e661f9 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2418,10 +2418,10 @@ namespace ts { * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph * as the fallback implementation does not check for circular references by default. */ - export const stringify: (value: any) => string = JSON && JSON.stringify + export const stringify: (value: any) => string = JSON && JSON.stringify ? JSON.stringify : stringifyFallback; - + function hasCycles(value: any, stack: any[]) { /* tslint:disable:no-null */ if (typeof value !== "object" || value === null) { From 04d53c1cfed6a01c8f8b84ce95f930c9585bd1a5 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 25 Nov 2015 14:35:44 -0800 Subject: [PATCH 42/51] Simpler inline cycle check for stringify --- src/compiler/utilities.ts | 44 +++++++++++---------------------------- 1 file changed, 12 insertions(+), 32 deletions(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 47941e661f9..b5eb227b58c 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2422,38 +2422,10 @@ namespace ts { ? JSON.stringify : stringifyFallback; - function hasCycles(value: any, stack: any[]) { - /* tslint:disable:no-null */ - if (typeof value !== "object" || value === null) { - return false; - } - /* tslint:enable:no-null */ - - if (stack.lastIndexOf(value) !== -1) { - return true; - } - - stack.push(value); - - for (const key in value) { - if (hasProperty(value, key) && hasCycles(value[key], stack)) { - return true; - } - } - - stack.pop(); - return false; - } - /** - * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph - * as the fallback implementation does not check for circular references by default. + * Serialize an object graph into a JSON string. */ function stringifyFallback(value: any): string { - if (Debug.shouldAssert(AssertionLevel.Aggressive)) { - Debug.assert(!hasCycles(value, []), "Detected circular reference before serializing object graph."); - } - // JSON.stringify returns `undefined` here, instead of the string "undefined". return value === undefined ? undefined : stringifyValue(value); } @@ -2462,10 +2434,18 @@ namespace ts { return typeof value === "string" ? `"${escapeString(value)}"` : typeof value === "number" ? isFinite(value) ? String(value) : "null" : typeof value === "boolean" ? value ? "true" : "false" - : typeof value === "object" ? isArray(value) ? stringifyArray(value) : stringifyObject(value) + : typeof value === "object" && value ? isArray(value) ? cycleCheck(stringifyArray, value) : cycleCheck(stringifyObject, value) : /*fallback*/ "null"; } + function cycleCheck(cb: (value: any) => string, value: any) { + Debug.assert(!value.hasOwnProperty("__cycle"), "Converting circular structure to JSON"); + value.__cycle = true; + const result = cb(value); + delete value.__cycle; + return result; + } + function stringifyArray(value: any) { return `[${reduceLeft(value, stringifyElement, "")}]`; } @@ -2475,11 +2455,11 @@ namespace ts { } function stringifyObject(value: any) { - return value ? `{${reduceProperties(value, stringifyProperty, "")}}` : "null"; + return `{${reduceProperties(value, stringifyProperty, "")}}`; } function stringifyProperty(memo: string, value: any, key: string) { - return value === undefined || typeof value === "function" ? memo + return value === undefined || typeof value === "function" || key === "__cycle" ? memo : (memo ? memo + "," : memo) + `"${escapeString(key)}":${stringifyValue(value)}`; } From b5c64ad5163203ea1e536ab9ed98a88068ff0ac9 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 25 Nov 2015 15:34:25 -0800 Subject: [PATCH 43/51] Test case for binder errors in .js file --- .../reference/jsFileCompilationBindErrors.js | 25 ++++++++++++++++++ .../jsFileCompilationBindErrors.symbols | 21 +++++++++++++++ .../jsFileCompilationBindErrors.types | 26 +++++++++++++++++++ .../compiler/jsFileCompilationBindErrors.ts | 15 +++++++++++ 4 files changed, 87 insertions(+) create mode 100644 tests/baselines/reference/jsFileCompilationBindErrors.js create mode 100644 tests/baselines/reference/jsFileCompilationBindErrors.symbols create mode 100644 tests/baselines/reference/jsFileCompilationBindErrors.types create mode 100644 tests/cases/compiler/jsFileCompilationBindErrors.ts diff --git a/tests/baselines/reference/jsFileCompilationBindErrors.js b/tests/baselines/reference/jsFileCompilationBindErrors.js new file mode 100644 index 00000000000..e4b515e2b69 --- /dev/null +++ b/tests/baselines/reference/jsFileCompilationBindErrors.js @@ -0,0 +1,25 @@ +//// [a.js] +let C = "sss"; +let C = 0; // Error: Cannot redeclare block-scoped variable 'C'. + +function f() { + return; + return; // Error: Unreachable code detected. +} + +function b() { + "use strict"; + var arguments = 0; // Error: Invalid use of 'arguments' in strict mode. +} + +//// [a.js] +var C = "sss"; +var C = 0; // Error: Cannot redeclare block-scoped variable 'C'. +function f() { + return; + return; // Error: Unreachable code detected. +} +function b() { + "use strict"; + var arguments = 0; // Error: Invalid use of 'arguments' in strict mode. +} diff --git a/tests/baselines/reference/jsFileCompilationBindErrors.symbols b/tests/baselines/reference/jsFileCompilationBindErrors.symbols new file mode 100644 index 00000000000..6ad06da1df6 --- /dev/null +++ b/tests/baselines/reference/jsFileCompilationBindErrors.symbols @@ -0,0 +1,21 @@ +=== tests/cases/compiler/a.js === +let C = "sss"; +>C : Symbol(C, Decl(a.js, 0, 3)) + +let C = 0; // Error: Cannot redeclare block-scoped variable 'C'. +>C : Symbol(C, Decl(a.js, 1, 3)) + +function f() { +>f : Symbol(f, Decl(a.js, 1, 10)) + + return; + return; // Error: Unreachable code detected. +} + +function b() { +>b : Symbol(b, Decl(a.js, 6, 1)) + + "use strict"; + var arguments = 0; // Error: Invalid use of 'arguments' in strict mode. +>arguments : Symbol(arguments, Decl(a.js, 10, 7)) +} diff --git a/tests/baselines/reference/jsFileCompilationBindErrors.types b/tests/baselines/reference/jsFileCompilationBindErrors.types new file mode 100644 index 00000000000..113bcd08bc9 --- /dev/null +++ b/tests/baselines/reference/jsFileCompilationBindErrors.types @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.js === +let C = "sss"; +>C : string +>"sss" : string + +let C = 0; // Error: Cannot redeclare block-scoped variable 'C'. +>C : number +>0 : number + +function f() { +>f : () => void + + return; + return; // Error: Unreachable code detected. +} + +function b() { +>b : () => void + + "use strict"; +>"use strict" : string + + var arguments = 0; // Error: Invalid use of 'arguments' in strict mode. +>arguments : number +>0 : number +} diff --git a/tests/cases/compiler/jsFileCompilationBindErrors.ts b/tests/cases/compiler/jsFileCompilationBindErrors.ts new file mode 100644 index 00000000000..37bdbc62916 --- /dev/null +++ b/tests/cases/compiler/jsFileCompilationBindErrors.ts @@ -0,0 +1,15 @@ +// @allowJs: true +// @noEmit: true +// @filename: a.js +let C = "sss"; +let C = 0; // Error: Cannot redeclare block-scoped variable 'C'. + +function f() { + return; + return; // Error: Unreachable code detected. +} + +function b() { + "use strict"; + var arguments = 0; // Error: Invalid use of 'arguments' in strict mode. +} \ No newline at end of file From 39266849f14121bef62637cd87b60f12b0f239eb Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 25 Nov 2015 16:58:44 -0800 Subject: [PATCH 44/51] accept projects tests baselines --- .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ .../amd/bin/test.d.ts | 28 +++++++++++++++++++ 9 files changed, 252 insertions(+) create mode 100644 tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts create mode 100644 tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts new file mode 100644 index 00000000000..d42fc1cd136 --- /dev/null +++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts @@ -0,0 +1,28 @@ +declare module "outputdir_module_multifolder/ref/m1" { + export var m1_a1: number; + export class m1_c1 { + m1_c1_p1: number; + } + export var m1_instance1: m1_c1; + export function m1_f1(): m1_c1; +} +declare module "outputdir_module_multifolder_ref/m2" { + export var m2_a1: number; + export class m2_c1 { + m2_c1_p1: number; + } + export var m2_instance1: m2_c1; + export function m2_f1(): m2_c1; +} +declare module "test" { + import m1 = require("outputdir_module_multifolder/ref/m1"); + import m2 = require("outputdir_module_multifolder_ref/m2"); + export var a1: number; + export class c1 { + p1: number; + } + export var instance1: c1; + export function f1(): c1; + export var a2: typeof m1.m1_c1; + export var a3: typeof m2.m2_c1; +} From adc3f2bd199c5441c7922164bba005ba26eb5a9d Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 25 Nov 2015 17:27:07 -0800 Subject: [PATCH 45/51] update description --- src/compiler/commandLineParser.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 8ec47fcffef..034b7022e82 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -283,7 +283,7 @@ namespace ts { { name: "allowSyntheticDefaultImports", type: "boolean", - description: Diagnostics.Allow_default_imports_from_modules_with_no_default_export + description: Diagnostics.Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking }, { name: "allowJs", diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 9646353d8f8..882fd41d6d4 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2109,7 +2109,7 @@ "category": "Message", "code": 6010 }, - "Allow default imports from modules with no default export": { + "Allow default imports from modules with no default export. This does not affect code emit, just typechecking.": { "category": "Message", "code": 6011 }, From 62fb5e85e4d432faa241778b06015a636738f8d1 Mon Sep 17 00:00:00 2001 From: Yui T Date: Wed, 25 Nov 2015 17:33:11 -0800 Subject: [PATCH 46/51] Include debug assert --- src/services/services.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index b53ff02e195..ea5a4a027cc 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1901,7 +1901,7 @@ namespace ts { sourceMapText = text; } else { - Debug.assert(outputText === undefined, "Unexpected multiple outputs for the file: " + name); + Debug.assert(outputText === undefined, `Unexpected multiple outputs for the file: '${name}'`); outputText = text; } }, @@ -4248,7 +4248,8 @@ namespace ts { else { // Method/function type parameter let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter); - declaration = declaration ? declaration.parent : undefined; + Debug.assert(declaration !== undefined); + declaration = declaration.parent; if (declaration) { if (isFunctionLikeKind(declaration.kind)) { From 2198988e7be39ba227a46f128944d1b72f227fd2 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 25 Nov 2015 17:46:27 -0800 Subject: [PATCH 47/51] accept baselines --- .../baselines/reference/decoratedDefaultExportsGetExportedAmd.js | 1 + .../reference/decoratedDefaultExportsGetExportedCommonjs.js | 1 + .../reference/decoratedDefaultExportsGetExportedSystem.js | 1 + .../baselines/reference/decoratedDefaultExportsGetExportedUmd.js | 1 + tests/baselines/reference/defaultExportsGetExportedAmd.js | 1 + tests/baselines/reference/defaultExportsGetExportedCommonjs.js | 1 + tests/baselines/reference/defaultExportsGetExportedSystem.js | 1 + tests/baselines/reference/defaultExportsGetExportedUmd.js | 1 + 8 files changed, 8 insertions(+) diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js index 441d8b0d70a..3fb23375f02 100644 --- a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js @@ -14,6 +14,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, return c > 3 && r && Object.defineProperty(target, key, r), r; }; define(["require", "exports"], function (require, exports) { + "use strict"; var decorator; let Foo = class { }; diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js index 8818241c9b5..32acfbbea39 100644 --- a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js @@ -7,6 +7,7 @@ export default class Foo {} //// [decoratedDefaultExportsGetExportedCommonjs.js] +"use strict"; var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js index 1ae54560ae3..a2b22e4ccdb 100644 --- a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js @@ -8,6 +8,7 @@ export default class Foo {} //// [decoratedDefaultExportsGetExportedSystem.js] System.register([], function(exports_1) { + "use strict"; var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js index 118af702fc1..06cee476b57 100644 --- a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js +++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js @@ -21,6 +21,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, define(["require", "exports"], factory); } })(function (require, exports) { + "use strict"; var decorator; let Foo = class { }; diff --git a/tests/baselines/reference/defaultExportsGetExportedAmd.js b/tests/baselines/reference/defaultExportsGetExportedAmd.js index 4eba3ba9600..b9387a2cc84 100644 --- a/tests/baselines/reference/defaultExportsGetExportedAmd.js +++ b/tests/baselines/reference/defaultExportsGetExportedAmd.js @@ -4,6 +4,7 @@ export default class Foo {} //// [defaultExportsGetExportedAmd.js] define(["require", "exports"], function (require, exports) { + "use strict"; class Foo { } exports.default = Foo; diff --git a/tests/baselines/reference/defaultExportsGetExportedCommonjs.js b/tests/baselines/reference/defaultExportsGetExportedCommonjs.js index a19b99fe9d3..28301251efc 100644 --- a/tests/baselines/reference/defaultExportsGetExportedCommonjs.js +++ b/tests/baselines/reference/defaultExportsGetExportedCommonjs.js @@ -3,6 +3,7 @@ export default class Foo {} //// [defaultExportsGetExportedCommonjs.js] +"use strict"; class Foo { } exports.default = Foo; diff --git a/tests/baselines/reference/defaultExportsGetExportedSystem.js b/tests/baselines/reference/defaultExportsGetExportedSystem.js index 1f1a7c9dea6..7d5c6ee2854 100644 --- a/tests/baselines/reference/defaultExportsGetExportedSystem.js +++ b/tests/baselines/reference/defaultExportsGetExportedSystem.js @@ -4,6 +4,7 @@ export default class Foo {} //// [defaultExportsGetExportedSystem.js] System.register([], function(exports_1) { + "use strict"; var Foo; return { setters:[], diff --git a/tests/baselines/reference/defaultExportsGetExportedUmd.js b/tests/baselines/reference/defaultExportsGetExportedUmd.js index ed3639ace55..902fc89c1d4 100644 --- a/tests/baselines/reference/defaultExportsGetExportedUmd.js +++ b/tests/baselines/reference/defaultExportsGetExportedUmd.js @@ -11,6 +11,7 @@ export default class Foo {} define(["require", "exports"], factory); } })(function (require, exports) { + "use strict"; class Foo { } exports.default = Foo; From fd5f4404cb4bed07c234ec468d7ab9815cc59a73 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 25 Nov 2015 18:22:44 -0800 Subject: [PATCH 48/51] accept new baselines --- tests/baselines/reference/allowSyntheticDefaultImports1.js | 2 ++ tests/baselines/reference/allowSyntheticDefaultImports2.js | 2 ++ tests/baselines/reference/allowSyntheticDefaultImports3.js | 2 ++ tests/baselines/reference/allowSyntheticDefaultImports4.js | 1 + tests/baselines/reference/allowSyntheticDefaultImports5.js | 1 + tests/baselines/reference/allowSyntheticDefaultImports6.js | 1 + 6 files changed, 9 insertions(+) diff --git a/tests/baselines/reference/allowSyntheticDefaultImports1.js b/tests/baselines/reference/allowSyntheticDefaultImports1.js index bc78725cb1c..699880f930c 100644 --- a/tests/baselines/reference/allowSyntheticDefaultImports1.js +++ b/tests/baselines/reference/allowSyntheticDefaultImports1.js @@ -11,6 +11,7 @@ export class Foo { //// [b.js] +"use strict"; var Foo = (function () { function Foo() { } @@ -18,5 +19,6 @@ var Foo = (function () { })(); exports.Foo = Foo; //// [a.js] +"use strict"; var b_1 = require("./b"); exports.x = new b_1["default"].Foo(); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports2.js b/tests/baselines/reference/allowSyntheticDefaultImports2.js index 3c1981bee9b..d21750c65fc 100644 --- a/tests/baselines/reference/allowSyntheticDefaultImports2.js +++ b/tests/baselines/reference/allowSyntheticDefaultImports2.js @@ -11,6 +11,7 @@ export class Foo { //// [b.js] System.register([], function(exports_1) { + "use strict"; var Foo; return { setters:[], @@ -26,6 +27,7 @@ System.register([], function(exports_1) { }); //// [a.js] System.register(["./b"], function(exports_1) { + "use strict"; var b_1; var x; return { diff --git a/tests/baselines/reference/allowSyntheticDefaultImports3.js b/tests/baselines/reference/allowSyntheticDefaultImports3.js index 2345ad65d10..8864a28e796 100644 --- a/tests/baselines/reference/allowSyntheticDefaultImports3.js +++ b/tests/baselines/reference/allowSyntheticDefaultImports3.js @@ -12,6 +12,7 @@ export class Foo { //// [b.js] System.register([], function(exports_1) { + "use strict"; var Foo; return { setters:[], @@ -27,6 +28,7 @@ System.register([], function(exports_1) { }); //// [a.js] System.register(["./b"], function(exports_1) { + "use strict"; var b_1; var x; return { diff --git a/tests/baselines/reference/allowSyntheticDefaultImports4.js b/tests/baselines/reference/allowSyntheticDefaultImports4.js index 583d4f0bc92..747f59dc904 100644 --- a/tests/baselines/reference/allowSyntheticDefaultImports4.js +++ b/tests/baselines/reference/allowSyntheticDefaultImports4.js @@ -12,5 +12,6 @@ export var x = new Foo(); //// [a.js] +"use strict"; var b_1 = require("./b"); exports.x = new b_1["default"](); diff --git a/tests/baselines/reference/allowSyntheticDefaultImports5.js b/tests/baselines/reference/allowSyntheticDefaultImports5.js index e1528e27915..c9121512b61 100644 --- a/tests/baselines/reference/allowSyntheticDefaultImports5.js +++ b/tests/baselines/reference/allowSyntheticDefaultImports5.js @@ -13,6 +13,7 @@ export var x = new Foo(); //// [a.js] System.register(["./b"], function(exports_1) { + "use strict"; var b_1; var x; return { diff --git a/tests/baselines/reference/allowSyntheticDefaultImports6.js b/tests/baselines/reference/allowSyntheticDefaultImports6.js index 0e27ce127d8..64d52e70af9 100644 --- a/tests/baselines/reference/allowSyntheticDefaultImports6.js +++ b/tests/baselines/reference/allowSyntheticDefaultImports6.js @@ -13,6 +13,7 @@ export var x = new Foo(); //// [a.js] System.register(["./b"], function(exports_1) { + "use strict"; var b_1; var x; return { From ed453ddcfc8c578aaacccd9fb05368f89987e611 Mon Sep 17 00:00:00 2001 From: Jeffrey Morlan Date: Sat, 28 Nov 2015 10:41:37 -0800 Subject: [PATCH 49/51] Add comment --- src/compiler/checker.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c13f678261c..c09d36bcd34 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11205,6 +11205,8 @@ namespace ts { seen = c === node; } }); + // We may be here because of some extra junk between overloads that could not be parsed into a valid node. + // In this case the subsequent node is not really consecutive (.pos !== node.end), and we must ignore it here. if (subsequentNode && subsequentNode.pos === node.end) { if (subsequentNode.kind === node.kind) { const errorNode: Node = (subsequentNode).name || subsequentNode; From 9552d4da4471aa44e5f1c7e437f9901d1197bea9 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Sun, 29 Nov 2015 21:17:31 -0800 Subject: [PATCH 50/51] ignore all trivia except singleline comments when processing tripleslash references --- src/compiler/parser.ts | 10 ++++---- .../reference/shebangBeforeReferences.js | 21 ++++++++++++++++ .../reference/shebangBeforeReferences.symbols | 23 ++++++++++++++++++ .../reference/shebangBeforeReferences.types | 24 +++++++++++++++++++ .../cases/compiler/shebangBeforeReferences.ts | 15 ++++++++++++ 5 files changed, 89 insertions(+), 4 deletions(-) create mode 100644 tests/baselines/reference/shebangBeforeReferences.js create mode 100644 tests/baselines/reference/shebangBeforeReferences.symbols create mode 100644 tests/baselines/reference/shebangBeforeReferences.types create mode 100644 tests/cases/compiler/shebangBeforeReferences.ts diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index cb96731dbcf..e917ef9bfe6 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -5428,11 +5428,13 @@ namespace ts { // reference comment. while (true) { const kind = triviaScanner.scan(); - if (kind === SyntaxKind.WhitespaceTrivia || kind === SyntaxKind.NewLineTrivia || kind === SyntaxKind.MultiLineCommentTrivia) { - continue; - } if (kind !== SyntaxKind.SingleLineCommentTrivia) { - break; + if (isTrivia(kind)) { + continue; + } + else { + break; + } } const range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() }; diff --git a/tests/baselines/reference/shebangBeforeReferences.js b/tests/baselines/reference/shebangBeforeReferences.js new file mode 100644 index 00000000000..6be2707277d --- /dev/null +++ b/tests/baselines/reference/shebangBeforeReferences.js @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/shebangBeforeReferences.ts] //// + +//// [f.d.ts] + +declare module "test" { + let x: number; +} + +//// [f.ts] +#!/usr/bin/env node + +/// + +declare function use(f: number): void; +import {x} from "test"; +use(x); + +//// [f.js] +#!/usr/bin/env node"use strict"; +var test_1 = require("test"); +use(test_1.x); diff --git a/tests/baselines/reference/shebangBeforeReferences.symbols b/tests/baselines/reference/shebangBeforeReferences.symbols new file mode 100644 index 00000000000..23bfe58fc62 --- /dev/null +++ b/tests/baselines/reference/shebangBeforeReferences.symbols @@ -0,0 +1,23 @@ +=== tests/cases/compiler/f.ts === +#!/usr/bin/env node + +/// + +declare function use(f: number): void; +>use : Symbol(use, Decl(f.ts, 0, 0)) +>f : Symbol(f, Decl(f.ts, 4, 21)) + +import {x} from "test"; +>x : Symbol(x, Decl(f.ts, 5, 8)) + +use(x); +>use : Symbol(use, Decl(f.ts, 0, 0)) +>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)) +} + diff --git a/tests/baselines/reference/shebangBeforeReferences.types b/tests/baselines/reference/shebangBeforeReferences.types new file mode 100644 index 00000000000..89b63a1a0b4 --- /dev/null +++ b/tests/baselines/reference/shebangBeforeReferences.types @@ -0,0 +1,24 @@ +=== tests/cases/compiler/f.ts === +#!/usr/bin/env node + +/// + +declare function use(f: number): void; +>use : (f: number) => void +>f : number + +import {x} from "test"; +>x : number + +use(x); +>use(x) : void +>use : (f: number) => void +>x : number + +=== tests/cases/compiler/f.d.ts === + +declare module "test" { + let x: number; +>x : number +} + diff --git a/tests/cases/compiler/shebangBeforeReferences.ts b/tests/cases/compiler/shebangBeforeReferences.ts new file mode 100644 index 00000000000..f03933959ee --- /dev/null +++ b/tests/cases/compiler/shebangBeforeReferences.ts @@ -0,0 +1,15 @@ +// @module: commonjs + +// @filename: f.d.ts +declare module "test" { + let x: number; +} + +// @filename: f.ts +#!/usr/bin/env node + +/// + +declare function use(f: number): void; +import {x} from "test"; +use(x); \ No newline at end of file From 2cc7a7904ac932f3d2fce7afc1d2b16b1723527a Mon Sep 17 00:00:00 2001 From: Yui T Date: Mon, 30 Nov 2015 09:10:14 -0800 Subject: [PATCH 51/51] use const --- src/services/services.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/services/services.ts b/src/services/services.ts index 18fa58a74f7..4e0a0265b91 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4254,7 +4254,7 @@ namespace ts { if (declaration) { if (isFunctionLikeKind(declaration.kind)) { - let signature = typeChecker.getSignatureFromDeclaration(declaration); + const signature = typeChecker.getSignatureFromDeclaration(declaration); if (declaration.kind === SyntaxKind.ConstructSignature) { displayParts.push(keywordPart(SyntaxKind.NewKeyword)); displayParts.push(spacePart());