Add command line flag to allow synthetic default exports

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 = typeof compilerOptions.allowSyntheticDefaultImports !== "undefined" ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System;
 
         const emitResolver = createResolver();
 
@@ -768,9 +769,12 @@ namespace ts {
             const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>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;
             }
         }

src/compiler/commandLineParser.ts

@@ -280,10 +280,15 @@ namespace ts {
             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_This_does_not_affect_code_emit_just_typechecking
+        },
         {
             name: "allowJs",
             type: "boolean",
-            description: Diagnostics.Allow_javascript_files_to_be_compiled,
+            description: Diagnostics.Allow_javascript_files_to_be_compiled
         }
     ];
 
@@ -488,7 +493,7 @@ namespace ts {
             fileNames: getFileNames(),
             errors
         };
-
+
         function getFileNames(): string[] {
             let fileNames: string[] = [];
             if (hasProperty(json, "files")) {

src/compiler/diagnosticMessages.json

@@ -2117,6 +2117,10 @@
         "category": "Message",
         "code": 6010
     },
+    "Allow default imports from modules with no default export. This does not affect code emit, just typechecking.": {
+        "category": "Message",
+        "code": 6011
+    },
   "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES2015' (experimental)": {
     "category": "Message",
     "code": 6015

src/compiler/types.ts

@@ -2372,6 +2372,7 @@ namespace ts {
         noImplicitReturns?: boolean;
         noFallthroughCasesInSwitch?: boolean;
         forceConsistentCasingInFileNames?: boolean;
+        allowSyntheticDefaultImports?: boolean;
         allowJs?: boolean;
         /* @internal */ stripInternal?: boolean;
 

tests/baselines/reference/allowSyntheticDefaultImports1.js

@@ -0,0 +1,24 @@
+//// [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]
+"use strict";
+var Foo = (function () {
+    function Foo() {
+    }
+    return Foo;
+})();
+exports.Foo = Foo;
+//// [a.js]
+"use strict";
+var b_1 = require("./b");
+exports.x = new b_1["default"].Foo();

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))
+}
+

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
+}
+

tests/baselines/reference/allowSyntheticDefaultImports2.js

@@ -0,0 +1,42 @@
+//// [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) {
+    "use strict";
+    var Foo;
+    return {
+        setters:[],
+        execute: function() {
+            Foo = (function () {
+                function Foo() {
+                }
+                return Foo;
+            })();
+            exports_1("Foo", Foo);
+        }
+    }
+});
+//// [a.js]
+System.register(["./b"], function(exports_1) {
+    "use strict";
+    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());
+        }
+    }
+});

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))
+}

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
+}

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;
+    }
+

tests/baselines/reference/allowSyntheticDefaultImports3.js

@@ -0,0 +1,43 @@
+//// [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) {
+    "use strict";
+    var Foo;
+    return {
+        setters:[],
+        execute: function() {
+            Foo = (function () {
+                function Foo() {
+                }
+                return Foo;
+            })();
+            exports_1("Foo", Foo);
+        }
+    }
+});
+//// [a.js]
+System.register(["./b"], function(exports_1) {
+    "use strict";
+    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());
+        }
+    }
+});

tests/baselines/reference/allowSyntheticDefaultImports4.js

@@ -0,0 +1,17 @@
+//// [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]
+"use strict";
+var b_1 = require("./b");
+exports.x = new b_1["default"]();

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))
+

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
+

tests/baselines/reference/allowSyntheticDefaultImports5.js

@@ -0,0 +1,28 @@
+//// [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) {
+    "use strict";
+    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"]());
+        }
+    }
+});

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))
+

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
+