diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 4c979486ff3..71074c53d9c 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -2642,7 +2642,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                     writeLine();
                     emitStart(node);
 
-                    if (compilerOptions.module === ModuleKind.System) {
+                    // emit call to exporter only for top level nodes
+                    if (compilerOptions.module === ModuleKind.System && node.parent === currentSourceFile) {
                         // emit export default <smth> as
                         // export("default", <smth>)
                         write(`${exportFunctionForFile}("`);
@@ -4376,15 +4377,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                     return;
                 }
 
-                if (!(node.flags & NodeFlags.Export) || isES6ExportedDeclaration(node)) {
-                    emitStart(node);
-                    if (isES6ExportedDeclaration(node)) {
-                        write("export ");
+                if (!shouldHoistDeclarationInSystemJsModule(node)) {
+                    // do not emit var if variable was already hoisted
+                    if (!(node.flags & NodeFlags.Export) || isES6ExportedDeclaration(node)) {
+                        emitStart(node);
+                        if (isES6ExportedDeclaration(node)) {
+                            write("export ");
+                        }
+                        write("var ");
+                        emit(node.name);
+                        emitEnd(node);
+                        write(";");
                     }
-                    write("var ");
-                    emit(node.name);
-                    emitEnd(node);
-                    write(";");
                 }
                 writeLine();
                 emitStart(node);
@@ -4406,7 +4410,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 ");
@@ -4417,6 +4422,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 exporter for enum
+                        writeLine();
+                        write(`${exportFunctionForFile}("`);
+                        emitDeclarationName(node);
+                        write(`", `);
+                        emitDeclarationName(node);
+                        write(")");
+                    }
                     emitExportMemberAssignments(node.name);
                 }
             }
@@ -5097,7 +5111,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)[];
 
@@ -5106,13 +5120,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);
@@ -5156,7 +5187,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                     }
 
                     if (node.kind === SyntaxKind.ClassDeclaration) {
-                        // TODO: rename block scoped classes
                         if (!hoistedVars) {
                             hoistedVars = [];
                         }
@@ -5165,12 +5195,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;
                     }
 
diff --git a/tests/baselines/reference/systemModuleConstEnums.js b/tests/baselines/reference/systemModuleConstEnums.js
new file mode 100644
index 00000000000..126e6266b2c
--- /dev/null
+++ b/tests/baselines/reference/systemModuleConstEnums.js
@@ -0,0 +1,27 @@
+//// [systemModuleConstEnums.ts]
+
+declare function use(a: any);
+const enum TopLevelConstEnum { X }
+
+export function foo() {
+    use(TopLevelConstEnum.X);
+    use(M.NonTopLevelConstEnum.X);
+}
+
+module M {
+    export const enum NonTopLevelConstEnum { X }
+}
+
+//// [systemModuleConstEnums.js]
+System.register([], function(exports_1) {
+    function foo() {
+        use(0 /* X */);
+        use(0 /* X */);
+    }
+    exports_1("foo", foo);
+    return {
+        setters:[],
+        execute: function() {
+        }
+    }
+});
diff --git a/tests/baselines/reference/systemModuleConstEnums.symbols b/tests/baselines/reference/systemModuleConstEnums.symbols
new file mode 100644
index 00000000000..171f24628ec
--- /dev/null
+++ b/tests/baselines/reference/systemModuleConstEnums.symbols
@@ -0,0 +1,35 @@
+=== tests/cases/compiler/systemModuleConstEnums.ts ===
+
+declare function use(a: any);
+>use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0))
+>a : Symbol(a, Decl(systemModuleConstEnums.ts, 1, 21))
+
+const enum TopLevelConstEnum { X }
+>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 1, 29))
+>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30))
+
+export function foo() {
+>foo : Symbol(foo, Decl(systemModuleConstEnums.ts, 2, 34))
+
+    use(TopLevelConstEnum.X);
+>use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0))
+>TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30))
+>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 1, 29))
+>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30))
+
+    use(M.NonTopLevelConstEnum.X);
+>use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0))
+>M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44))
+>M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10))
+>M : Symbol(M, Decl(systemModuleConstEnums.ts, 7, 1))
+>NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10))
+>X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44))
+}
+
+module M {
+>M : Symbol(M, Decl(systemModuleConstEnums.ts, 7, 1))
+
+    export const enum NonTopLevelConstEnum { X }
+>NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10))
+>X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44))
+}
diff --git a/tests/baselines/reference/systemModuleConstEnums.types b/tests/baselines/reference/systemModuleConstEnums.types
new file mode 100644
index 00000000000..193de0da3ab
--- /dev/null
+++ b/tests/baselines/reference/systemModuleConstEnums.types
@@ -0,0 +1,37 @@
+=== tests/cases/compiler/systemModuleConstEnums.ts ===
+
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+const enum TopLevelConstEnum { X }
+>TopLevelConstEnum : TopLevelConstEnum
+>X : TopLevelConstEnum
+
+export function foo() {
+>foo : () => void
+
+    use(TopLevelConstEnum.X);
+>use(TopLevelConstEnum.X) : any
+>use : (a: any) => any
+>TopLevelConstEnum.X : TopLevelConstEnum
+>TopLevelConstEnum : typeof TopLevelConstEnum
+>X : TopLevelConstEnum
+
+    use(M.NonTopLevelConstEnum.X);
+>use(M.NonTopLevelConstEnum.X) : any
+>use : (a: any) => any
+>M.NonTopLevelConstEnum.X : M.NonTopLevelConstEnum
+>M.NonTopLevelConstEnum : typeof M.NonTopLevelConstEnum
+>M : typeof M
+>NonTopLevelConstEnum : typeof M.NonTopLevelConstEnum
+>X : M.NonTopLevelConstEnum
+}
+
+module M {
+>M : typeof M
+
+    export const enum NonTopLevelConstEnum { X }
+>NonTopLevelConstEnum : NonTopLevelConstEnum
+>X : NonTopLevelConstEnum
+}
diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js
new file mode 100644
index 00000000000..381331a84db
--- /dev/null
+++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js
@@ -0,0 +1,37 @@
+//// [systemModuleConstEnumsSeparateCompilation.ts]
+
+declare function use(a: any);
+const enum TopLevelConstEnum { X }
+
+export function foo() {
+    use(TopLevelConstEnum.X);
+    use(M.NonTopLevelConstEnum.X);
+}
+
+module M {
+    export const enum NonTopLevelConstEnum { X }
+}
+
+//// [systemModuleConstEnumsSeparateCompilation.js]
+System.register([], function(exports_1) {
+    var TopLevelConstEnum, M;
+    function foo() {
+        use(TopLevelConstEnum.X);
+        use(M.NonTopLevelConstEnum.X);
+    }
+    exports_1("foo", foo);
+    return {
+        setters:[],
+        execute: function() {
+            (function (TopLevelConstEnum) {
+                TopLevelConstEnum[TopLevelConstEnum["X"] = 0] = "X";
+            })(TopLevelConstEnum || (TopLevelConstEnum = {}));
+            (function (M) {
+                (function (NonTopLevelConstEnum) {
+                    NonTopLevelConstEnum[NonTopLevelConstEnum["X"] = 0] = "X";
+                })(M.NonTopLevelConstEnum || (M.NonTopLevelConstEnum = {}));
+                var NonTopLevelConstEnum = M.NonTopLevelConstEnum;
+            })(M || (M = {}));
+        }
+    }
+});
diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols
new file mode 100644
index 00000000000..d57740b75e9
--- /dev/null
+++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols
@@ -0,0 +1,35 @@
+=== tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts ===
+
+declare function use(a: any);
+>use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0))
+>a : Symbol(a, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 21))
+
+const enum TopLevelConstEnum { X }
+>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 29))
+>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30))
+
+export function foo() {
+>foo : Symbol(foo, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 34))
+
+    use(TopLevelConstEnum.X);
+>use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0))
+>TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30))
+>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 29))
+>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30))
+
+    use(M.NonTopLevelConstEnum.X);
+>use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0))
+>M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44))
+>M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10))
+>M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 7, 1))
+>NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10))
+>X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44))
+}
+
+module M {
+>M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 7, 1))
+
+    export const enum NonTopLevelConstEnum { X }
+>NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10))
+>X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44))
+}
diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types
new file mode 100644
index 00000000000..c3a352f66ec
--- /dev/null
+++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types
@@ -0,0 +1,37 @@
+=== tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts ===
+
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+const enum TopLevelConstEnum { X }
+>TopLevelConstEnum : TopLevelConstEnum
+>X : TopLevelConstEnum
+
+export function foo() {
+>foo : () => void
+
+    use(TopLevelConstEnum.X);
+>use(TopLevelConstEnum.X) : any
+>use : (a: any) => any
+>TopLevelConstEnum.X : TopLevelConstEnum
+>TopLevelConstEnum : typeof TopLevelConstEnum
+>X : TopLevelConstEnum
+
+    use(M.NonTopLevelConstEnum.X);
+>use(M.NonTopLevelConstEnum.X) : any
+>use : (a: any) => any
+>M.NonTopLevelConstEnum.X : M.NonTopLevelConstEnum
+>M.NonTopLevelConstEnum : typeof M.NonTopLevelConstEnum
+>M : typeof M
+>NonTopLevelConstEnum : typeof M.NonTopLevelConstEnum
+>X : M.NonTopLevelConstEnum
+}
+
+module M {
+>M : typeof M
+
+    export const enum NonTopLevelConstEnum { X }
+>NonTopLevelConstEnum : NonTopLevelConstEnum
+>X : NonTopLevelConstEnum
+}
diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.js b/tests/baselines/reference/systemModuleDeclarationMerging.js
new file mode 100644
index 00000000000..b745ed04891
--- /dev/null
+++ b/tests/baselines/reference/systemModuleDeclarationMerging.js
@@ -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)
+        }
+    }
+});
diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.symbols b/tests/baselines/reference/systemModuleDeclarationMerging.symbols
new file mode 100644
index 00000000000..8efce4022ba
--- /dev/null
+++ b/tests/baselines/reference/systemModuleDeclarationMerging.symbols
@@ -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))
+
diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.types b/tests/baselines/reference/systemModuleDeclarationMerging.types
new file mode 100644
index 00000000000..20bf1e67f51
--- /dev/null
+++ b/tests/baselines/reference/systemModuleDeclarationMerging.types
@@ -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
+
diff --git a/tests/baselines/reference/systemModuleExportDefault.js b/tests/baselines/reference/systemModuleExportDefault.js
new file mode 100644
index 00000000000..4df3ec828c1
--- /dev/null
+++ b/tests/baselines/reference/systemModuleExportDefault.js
@@ -0,0 +1,67 @@
+//// [tests/cases/compiler/systemModuleExportDefault.ts] ////
+
+//// [file1.ts]
+
+export default function() {}
+
+//// [file2.ts]
+export default function foo() {}
+
+//// [file3.ts]
+export default class {}
+
+//// [file4.ts]
+export default class C {}
+
+
+
+//// [file1.js]
+System.register([], function(exports_1) {
+    function default_1() { }
+    exports_1("default", default_1);
+    return {
+        setters:[],
+        execute: function() {
+        }
+    }
+});
+//// [file2.js]
+System.register([], function(exports_1) {
+    function foo() { }
+    exports_1("default", foo);
+    return {
+        setters:[],
+        execute: function() {
+        }
+    }
+});
+//// [file3.js]
+System.register([], function(exports_1) {
+    var default_1;
+    return {
+        setters:[],
+        execute: function() {
+            default_1 = (function () {
+                function default_1() {
+                }
+                return default_1;
+            })();
+            exports_1("default", default_1);
+        }
+    }
+});
+//// [file4.js]
+System.register([], function(exports_1) {
+    var C;
+    return {
+        setters:[],
+        execute: function() {
+            C = (function () {
+                function C() {
+                }
+                return C;
+            })();
+            exports_1("default", C);
+        }
+    }
+});
diff --git a/tests/baselines/reference/systemModuleExportDefault.symbols b/tests/baselines/reference/systemModuleExportDefault.symbols
new file mode 100644
index 00000000000..d6e7cde9b71
--- /dev/null
+++ b/tests/baselines/reference/systemModuleExportDefault.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/file1.ts ===
+
+No type information for this code.export default function() {}
+No type information for this code.
+No type information for this code.=== tests/cases/compiler/file2.ts ===
+export default function foo() {}
+>foo : Symbol(foo, Decl(file2.ts, 0, 0))
+
+=== tests/cases/compiler/file3.ts ===
+export default class {}
+No type information for this code.
+No type information for this code.=== tests/cases/compiler/file4.ts ===
+export default class C {}
+>C : Symbol(C, Decl(file4.ts, 0, 0))
+
+
diff --git a/tests/baselines/reference/systemModuleExportDefault.types b/tests/baselines/reference/systemModuleExportDefault.types
new file mode 100644
index 00000000000..38b5abec8ed
--- /dev/null
+++ b/tests/baselines/reference/systemModuleExportDefault.types
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/file1.ts ===
+
+No type information for this code.export default function() {}
+No type information for this code.
+No type information for this code.=== tests/cases/compiler/file2.ts ===
+export default function foo() {}
+>foo : () => void
+
+=== tests/cases/compiler/file3.ts ===
+export default class {}
+No type information for this code.
+No type information for this code.=== tests/cases/compiler/file4.ts ===
+export default class C {}
+>C : C
+
+
diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js
new file mode 100644
index 00000000000..87e96259bf1
--- /dev/null
+++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js
@@ -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)
+        }
+    }
+});
diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols
new file mode 100644
index 00000000000..e0b69c71a2f
--- /dev/null
+++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols
@@ -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))
+}
diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types
new file mode 100644
index 00000000000..ffe3d23f7a6
--- /dev/null
+++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types
@@ -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
+}
diff --git a/tests/cases/compiler/systemModuleConstEnums.ts b/tests/cases/compiler/systemModuleConstEnums.ts
new file mode 100644
index 00000000000..6ad7f31ef91
--- /dev/null
+++ b/tests/cases/compiler/systemModuleConstEnums.ts
@@ -0,0 +1,13 @@
+// @module: system
+
+declare function use(a: any);
+const enum TopLevelConstEnum { X }
+
+export function foo() {
+    use(TopLevelConstEnum.X);
+    use(M.NonTopLevelConstEnum.X);
+}
+
+module M {
+    export const enum NonTopLevelConstEnum { X }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts b/tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts
new file mode 100644
index 00000000000..2fc4707b78e
--- /dev/null
+++ b/tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts
@@ -0,0 +1,14 @@
+// @module: system
+// @separateCompilation: true
+
+declare function use(a: any);
+const enum TopLevelConstEnum { X }
+
+export function foo() {
+    use(TopLevelConstEnum.X);
+    use(M.NonTopLevelConstEnum.X);
+}
+
+module M {
+    export const enum NonTopLevelConstEnum { X }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/systemModuleDeclarationMerging.ts b/tests/cases/compiler/systemModuleDeclarationMerging.ts
new file mode 100644
index 00000000000..45c59c5b5dc
--- /dev/null
+++ b/tests/cases/compiler/systemModuleDeclarationMerging.ts
@@ -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; }
\ No newline at end of file
diff --git a/tests/cases/compiler/systemModuleExportDefault.ts b/tests/cases/compiler/systemModuleExportDefault.ts
new file mode 100644
index 00000000000..102c03f0bcd
--- /dev/null
+++ b/tests/cases/compiler/systemModuleExportDefault.ts
@@ -0,0 +1,14 @@
+// @module: system
+
+// @filename: file1.ts
+export default function() {}
+
+// @filename: file2.ts
+export default function foo() {}
+
+// @filename: file3.ts
+export default class {}
+
+// @filename: file4.ts
+export default class C {}
+
diff --git a/tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts b/tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts
new file mode 100644
index 00000000000..756d430a2de
--- /dev/null
+++ b/tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts
@@ -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}
+}
\ No newline at end of file