microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-15 04:43:37 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

system: fix emit for exports of non-top level entities, fix emit for enums

Browse Source
This commit is contained in:
Vladimir Matveev
2015-05-11 00:07:49 -07:00
parent 681954bc59
commit cdbd6c6898
9 changed files with 289 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
src/compiler/emitter.ts
View File

@@ -2639,7 +2639,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
writeLine();
emitStart(node);
if (compilerOptions.module === ModuleKind.System) {
// emit call to exported only for top level nodes
if (compilerOptions.module === ModuleKind.System && node.parent === currentSourceFile) {
// emit export default <smth> as
// export("default", <smth>)
write(`${exportFunctionForFile}("`);
@@ -4403,7 +4404,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
emitModuleMemberName(node);
write(" = {}));");
emitEnd(node);
if (!isES6ExportedDeclaration(node) && node.flags & NodeFlags.Export) {
if (!isES6ExportedDeclaration(node) && node.flags & NodeFlags.Export && !shouldHoistDeclarationInSystemJsModule(node)) {
// do not emit var if variable was already hoisted
writeLine();
emitStart(node);
write("var ");
@@ -4414,6 +4416,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
write(";");
}
if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile) {
if (compilerOptions.module === ModuleKind.System && (node.flags & NodeFlags.Export)) {
// write the call to exported for enum
writeLine();
write(`${exportFunctionForFile}("`);
emitDeclarationName(node);
write(`", `);
emitDeclarationName(node);
write(")");
}
emitExportMemberAssignments(node.name);
}
}
@@ -5094,7 +5105,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
// in theory we should hoist only exported functions and its dependencies
// in practice to simplify things we'll hoist all source level functions and variable declaration
// including variables declarations for module and class declarations
let hoistedVars: (Identifier | ClassDeclaration | ModuleDeclaration)[];
let hoistedVars: (Identifier | ClassDeclaration | ModuleDeclaration | EnumDeclaration)[];
let hoistedFunctionDeclarations: FunctionDeclaration[];
let exportedDeclarations: (Identifier | Declaration)[];
@@ -5103,13 +5114,30 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
if (hoistedVars) {
writeLine();
write("var ");
let seen: Map<string> = {};
for (let i = 0; i < hoistedVars.length; ++i) {
let local = hoistedVars[i];
let name = local.kind === SyntaxKind.Identifier
? <Identifier>local
: <Identifier>(<ClassDeclaration | ModuleDeclaration | EnumDeclaration>local).name;
if (name) {
// do not emit duplicate entries (in case of declaration merging) in the list of hoisted variables
let text = unescapeIdentifier(name.text);
if (hasProperty(seen, text)) {
continue;
}
else {
seen[text] = text;
}
}
if (i !== 0) {
write(", ");
}
if (local.kind === SyntaxKind.ClassDeclaration || local.kind === SyntaxKind.ModuleDeclaration) {
emitDeclarationName(<ClassDeclaration | ModuleDeclaration>local);
if (local.kind === SyntaxKind.ClassDeclaration || local.kind === SyntaxKind.ModuleDeclaration || local.kind === SyntaxKind.EnumDeclaration) {
emitDeclarationName(<ClassDeclaration | ModuleDeclaration | EnumDeclaration>local);
}
else {
emit(local);
@@ -5153,7 +5181,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
}
if (node.kind === SyntaxKind.ClassDeclaration) {
// TODO: rename block scoped classes
if (!hoistedVars) {
hoistedVars = [];
}
@@ -5162,12 +5189,26 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
return;
}
if (node.kind === SyntaxKind.ModuleDeclaration && shouldEmitModuleDeclaration(<ModuleDeclaration>node)) {
if (!hoistedVars) {
hoistedVars = [];
if (node.kind === SyntaxKind.EnumDeclaration) {
if (shouldEmitEnumDeclaration(<EnumDeclaration>node)) {
if (!hoistedVars) {
hoistedVars = [];
}
hoistedVars.push(<ModuleDeclaration>node);
}
hoistedVars.push(<ModuleDeclaration>node);
return;
}
if (node.kind === SyntaxKind.ModuleDeclaration) {
if (shouldEmitModuleDeclaration(<ModuleDeclaration>node)) {
if (!hoistedVars) {
hoistedVars = [];
}
hoistedVars.push(<ModuleDeclaration>node);
}
return;
}

43
tests/baselines/reference/systemModuleDeclarationMerging.js Normal file
View File

@@ -0,0 +1,43 @@
//// [systemModuleDeclarationMerging.ts]
export function F() {}
export module F { var x; }
export class C {}
export module C { var x; }
export enum E {}
export module E { var x; }
//// [systemModuleDeclarationMerging.js]
System.register([], function(exports_1) {
var F, C, E;
function F() { }
exports_1("F", F);
return {
setters:[],
execute: function() {
(function (F) {
var x;
})(F = F || (F = {}));
exports_1("F", F)
C = (function () {
function C() {
}
return C;
})();
exports_1("C", C);
(function (C) {
var x;
})(C = C || (C = {}));
exports_1("C", C)
(function (E) {
})(E || (E = {}));
exports_1("E", E)
(function (E) {
var x;
})(E = E || (E = {}));
exports_1("E", E)
}
}
});

23
tests/baselines/reference/systemModuleDeclarationMerging.symbols Normal file
View File

@@ -0,0 +1,23 @@
=== tests/cases/compiler/systemModuleDeclarationMerging.ts ===
export function F() {}
>F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 1, 22))
export module F { var x; }
>F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 1, 22))
>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 2, 21))
export class C {}
>C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 2, 26), Decl(systemModuleDeclarationMerging.ts, 4, 17))
export module C { var x; }
>C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 2, 26), Decl(systemModuleDeclarationMerging.ts, 4, 17))
>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 5, 21))
export enum E {}
>E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 5, 26), Decl(systemModuleDeclarationMerging.ts, 7, 16))
export module E { var x; }
>E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 5, 26), Decl(systemModuleDeclarationMerging.ts, 7, 16))
>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 8, 21))

23
tests/baselines/reference/systemModuleDeclarationMerging.types Normal file
View File

@@ -0,0 +1,23 @@
=== tests/cases/compiler/systemModuleDeclarationMerging.ts ===
export function F() {}
>F : typeof F
export module F { var x; }
>F : typeof F
>x : any
export class C {}
>C : C
export module C { var x; }
>C : typeof C
>x : any
export enum E {}
>E : E
export module E { var x; }
>E : typeof E
>x : any

58
tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js Normal file
View File

@@ -0,0 +1,58 @@
//// [systemModuleNonTopLevelModuleMembers.ts]
export class TopLevelClass {}
export module TopLevelModule {var v;}
export function TopLevelFunction(): void {}
export enum TopLevelEnum {E}
export module TopLevelModule2 {
export class NonTopLevelClass {}
export module NonTopLevelModule {var v;}
export function NonTopLevelFunction(): void {}
export enum NonTopLevelEnum {E}
}
//// [systemModuleNonTopLevelModuleMembers.js]
System.register([], function(exports_1) {
var TopLevelClass, TopLevelModule, TopLevelEnum, TopLevelModule2;
function TopLevelFunction() { }
exports_1("TopLevelFunction", TopLevelFunction);
return {
setters:[],
execute: function() {
TopLevelClass = (function () {
function TopLevelClass() {
}
return TopLevelClass;
})();
exports_1("TopLevelClass", TopLevelClass);
(function (TopLevelModule) {
var v;
})(TopLevelModule = TopLevelModule || (TopLevelModule = {}));
exports_1("TopLevelModule", TopLevelModule)
(function (TopLevelEnum) {
TopLevelEnum[TopLevelEnum["E"] = 0] = "E";
})(TopLevelEnum || (TopLevelEnum = {}));
exports_1("TopLevelEnum", TopLevelEnum)
(function (TopLevelModule2) {
var NonTopLevelClass = (function () {
function NonTopLevelClass() {
}
return NonTopLevelClass;
})();
TopLevelModule2.NonTopLevelClass = NonTopLevelClass;
var NonTopLevelModule;
(function (NonTopLevelModule) {
var v;
})(NonTopLevelModule = TopLevelModule2.NonTopLevelModule || (TopLevelModule2.NonTopLevelModule = {}));
function NonTopLevelFunction() { }
TopLevelModule2.NonTopLevelFunction = NonTopLevelFunction;
(function (NonTopLevelEnum) {
NonTopLevelEnum[NonTopLevelEnum["E"] = 0] = "E";
})(TopLevelModule2.NonTopLevelEnum || (TopLevelModule2.NonTopLevelEnum = {}));
var NonTopLevelEnum = TopLevelModule2.NonTopLevelEnum;
})(TopLevelModule2 = TopLevelModule2 || (TopLevelModule2 = {}));
exports_1("TopLevelModule2", TopLevelModule2)
}
}
});

33
tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols Normal file
View File

@@ -0,0 +1,33 @@
=== tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts ===
export class TopLevelClass {}
>TopLevelClass : Symbol(TopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 0, 0))
export module TopLevelModule {var v;}
>TopLevelModule : Symbol(TopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 29))
>v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 33))
export function TopLevelFunction(): void {}
>TopLevelFunction : Symbol(TopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 37))
export enum TopLevelEnum {E}
>TopLevelEnum : Symbol(TopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 43))
>E : Symbol(TopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 4, 26))
export module TopLevelModule2 {
>TopLevelModule2 : Symbol(TopLevelModule2, Decl(systemModuleNonTopLevelModuleMembers.ts, 4, 28))
export class NonTopLevelClass {}
>NonTopLevelClass : Symbol(NonTopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 6, 31))
export module NonTopLevelModule {var v;}
>NonTopLevelModule : Symbol(NonTopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 36))
>v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 40))
export function NonTopLevelFunction(): void {}
>NonTopLevelFunction : Symbol(NonTopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 44))
export enum NonTopLevelEnum {E}
>NonTopLevelEnum : Symbol(NonTopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 9, 50))
>E : Symbol(NonTopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 10, 33))
}

33
tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types Normal file
View File

@@ -0,0 +1,33 @@
=== tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts ===
export class TopLevelClass {}
>TopLevelClass : TopLevelClass
export module TopLevelModule {var v;}
>TopLevelModule : typeof TopLevelModule
>v : any
export function TopLevelFunction(): void {}
>TopLevelFunction : () => void
export enum TopLevelEnum {E}
>TopLevelEnum : TopLevelEnum
>E : TopLevelEnum
export module TopLevelModule2 {
>TopLevelModule2 : typeof TopLevelModule2
export class NonTopLevelClass {}
>NonTopLevelClass : NonTopLevelClass
export module NonTopLevelModule {var v;}
>NonTopLevelModule : typeof NonTopLevelModule
>v : any
export function NonTopLevelFunction(): void {}
>NonTopLevelFunction : () => void
export enum NonTopLevelEnum {E}
>NonTopLevelEnum : NonTopLevelEnum
>E : NonTopLevelEnum
}

11
tests/cases/compiler/systemModuleDeclarationMerging.ts Normal file
View File

@@ -0,0 +1,11 @@
// @module: system
// @separateCompilation: true
export function F() {}
export module F { var x; }
export class C {}
export module C { var x; }
export enum E {}
export module E { var x; }

14
tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts Normal file
View File

@@ -0,0 +1,14 @@
// @module: system
// @separateCompilation: true
export class TopLevelClass {}
export module TopLevelModule {var v;}
export function TopLevelFunction(): void {}
export enum TopLevelEnum {E}
export module TopLevelModule2 {
export class NonTopLevelClass {}
export module NonTopLevelModule {var v;}
export function NonTopLevelFunction(): void {}
export enum NonTopLevelEnum {E}
}