Changed parser.ts to support all forms of export default described in #3792 (comment).

Added corresponding tests.
NB: export defaults are not yet transformed correctly.

Author: NaridaL

src/compiler/binder.ts

@@ -426,6 +426,15 @@ namespace ts {
                         symbol = createSymbol(SymbolFlags.None, name);
                     }
                 }
+                else if (isDefaultExport && parent && symbol.declarations && symbol.declarations.length) {
+                    // && parent because we only want to check the export default symbol.
+                    // if there is already an export default declaration, make sure that their local names are the same.
+                    if (symbol.declarations[0].localSymbol !== node.localSymbol) {
+                        const message = Diagnostics.Merged_default_exports_must_have_the_same_name;
+                        file.bindDiagnostics.push(createDiagnosticForNode(getNameOfDeclaration(symbol.declarations[0]) || symbol.declarations[0], message));
+                        file.bindDiagnostics.push(createDiagnosticForNode(getNameOfDeclaration(node) || node, message));
+                    }
+                }
             }
 
             addDeclarationToSymbol(symbol, node, includes);
@@ -472,8 +481,8 @@ namespace ts {
                     }
                     const exportKind = symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0;
                     const local = declareSymbol(container.locals!, /*parent*/ undefined, node, exportKind, symbolExcludes);
-                    local.exportSymbol = declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);
                     node.localSymbol = local;
+                    local.exportSymbol = declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);
                     return local;
                 }
                 else {
@@ -1381,7 +1390,7 @@ namespace ts {
         function bindJSDocTypeAlias(node: JSDocTypedefTag | JSDocCallbackTag) {
             if (node.fullName) {
                 setParentPointers(node, node.fullName);
-            }
+                }
         }
 
         function bindCallExpressionFlow(node: CallExpression) {

src/compiler/diagnosticMessages.json

@@ -2490,6 +2490,10 @@
         "code": 2734
     },
 
+    "Merged default exports must have the same name.": {
+        "category": "Error",
+        "code": 2734
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000

src/compiler/parser.ts

@@ -1414,11 +1414,11 @@ namespace ts {
                 case SyntaxKind.ExportKeyword:
                     nextToken();
                     if (token() === SyntaxKind.DefaultKeyword) {
-                        return lookAhead(nextTokenCanFollowDefaultKeyword);
+                        return lookAhead(nextTokenCanFollowDefaultModifier);
                     }
                     return token() !== SyntaxKind.AsteriskToken && token() !== SyntaxKind.AsKeyword && token() !== SyntaxKind.OpenBraceToken && canFollowModifier();
                 case SyntaxKind.DefaultKeyword:
-                    return nextTokenCanFollowDefaultKeyword();
+                    return nextTokenCanFollowDefaultModifier();
                 case SyntaxKind.StaticKeyword:
                 case SyntaxKind.GetKeyword:
                 case SyntaxKind.SetKeyword:
@@ -1441,12 +1441,37 @@ namespace ts {
                 || isLiteralPropertyName();
         }
 
-        function nextTokenCanFollowDefaultKeyword(): boolean {
+        /**
+         * For export default assignments like
+         *  "export default foo"
+         *  "export default async"
+         * no modifiers should be parsed.
+         */
+        function nextTokenCanFollowDefaultModifier(): boolean {
             nextToken();
-            return token() === SyntaxKind.ClassKeyword || token() === SyntaxKind.FunctionKeyword ||
-                token() === SyntaxKind.InterfaceKeyword ||
-                (token() === SyntaxKind.AbstractKeyword && lookAhead(nextTokenIsClassKeywordOnSameLine)) ||
-                (token() === SyntaxKind.AsyncKeyword && lookAhead(nextTokenIsFunctionKeywordOnSameLine));
+            switch (token()) {
+                case SyntaxKind.ClassKeyword:
+                case SyntaxKind.FunctionKeyword:
+                case SyntaxKind.EnumKeyword:
+                case SyntaxKind.NamespaceKeyword:
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.ConstKeyword:
+                    return true;
+
+                // The following keywords aren't reserved keywords and could be identifiers.
+                // We need to look at the next token to make sure these should be parsed as a modifier keyword,
+                // and not as an identifier. If they are followed by an identifier or a keyword on the same line,
+                // the current statement is not an export default assignment.
+                // See https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words
+                case SyntaxKind.InterfaceKeyword:
+                case SyntaxKind.AbstractKeyword:
+                case SyntaxKind.DeclareKeyword:
+                case SyntaxKind.AsyncKeyword:
+                case SyntaxKind.TypeKeyword:
+                    return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
+                default:
+                    return false;
+            }
         }
 
         // True if positioned at the start of a list element
@@ -4081,14 +4106,14 @@ namespace ts {
             let expression: MemberExpression;
             if (token() === SyntaxKind.ImportKeyword) {
                 if (lookAhead(nextTokenIsOpenParenOrLessThan)) {
-                    // We don't want to eagerly consume all import keyword as import call expression so we look ahead to find "("
-                    // For example:
-                    //      var foo3 = require("subfolder
-                    //      import * as foo1 from "module-from-node
-                    // We want this import to be a statement rather than import call expression
-                    sourceFile.flags |= NodeFlags.PossiblyContainsDynamicImport;
-                    expression = parseTokenNode<PrimaryExpression>();
-                }
+                // We don't want to eagerly consume all import keyword as import call expression so we look a head to find "("
+                // For example:
+                //      var foo3 = require("subfolder
+                //      import * as foo1 from "module-from-node
+                // We want this import to be a statement rather than import call expression
+                sourceFile.flags |= NodeFlags.PossiblyContainsDynamicImport;
+                expression = parseTokenNode<PrimaryExpression>();
+            }
                 else if (lookAhead(nextTokenIsDot)) {
                     // This is an 'import.*' metaproperty (i.e. 'import.meta')
                     const fullStart = scanner.getStartPos();
@@ -4101,7 +4126,7 @@ namespace ts {
 
                     sourceFile.flags |= NodeFlags.PossiblyContainsImportMeta;
                 }
-                else {
+            else {
                     expression = parseMemberExpressionOrHigher();
                 }
             }
@@ -5118,11 +5143,6 @@ namespace ts {
             return tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak();
         }
 
-        function nextTokenIsClassKeywordOnSameLine() {
-            nextToken();
-            return token() === SyntaxKind.ClassKeyword && !scanner.hasPrecedingLineBreak();
-        }
-
         function nextTokenIsFunctionKeywordOnSameLine() {
             nextToken();
             return token() === SyntaxKind.FunctionKeyword && !scanner.hasPrecedingLineBreak();
@@ -6233,7 +6253,7 @@ namespace ts {
             sourceFile.externalModuleIndicator =
                     forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) ||
                     getImportMetaIfNecessary(sourceFile);
-        }
+                    }
 
         function isAnExternalModuleIndicatorNode(node: Node) {
             return hasModifier(node, ModifierFlags.Export)
@@ -6243,17 +6263,17 @@ namespace ts {
                 || node.kind === SyntaxKind.ExportDeclaration
                     ? node
                     : undefined;
-        }
+                        }
 
         function getImportMetaIfNecessary(sourceFile: SourceFile) {
             return sourceFile.flags & NodeFlags.PossiblyContainsImportMeta ?
                 walkTreeForExternalModuleIndicators(sourceFile) :
                 undefined;
-        }
+                        }
 
         function walkTreeForExternalModuleIndicators(node: Node): Node | undefined {
             return isImportMeta(node) ? node : forEachChild(node, walkTreeForExternalModuleIndicators);
-        }
+                    }
 
         function isImportMeta(node: Node): boolean {
             return isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword && node.name.escapedText === "meta";
@@ -6468,7 +6488,7 @@ namespace ts {
                                 break;
                         }
                         nextJSDocToken();
-                    }
+                        }
                     removeLeadingNewlines(comments);
                     removeTrailingWhitespace(comments);
                     return createJSDocComment();

tests/baselines/reference/exportDefaultClodule.js

@@ -0,0 +1,36 @@
+//// [tests/cases/compiler/exportDefaultClodule.ts] ////
+
+//// [a.ts]
+// https://github.com/Microsoft/TypeScript/issues/3792
+export default class A {
+    A1: string
+}
+export default namespace A {
+    export const A2 = 32;
+}
+
+//// [b.ts]
+import A from "./a";
+
+const a = new A();
+const a2 = A.A2;
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+// https://github.com/Microsoft/TypeScript/issues/3792
+var A = /** @class */ (function () {
+    function A() {
+    }
+    return A;
+}());
+exports["default"] = A;
+(function (A) {
+    A.A2 = 32;
+})(A = exports.A || (exports.A = {}));
+//// [b.js]
+"use strict";
+exports.__esModule = true;
+var a_1 = require("./a");
+var a = new a_1["default"]();
+var a2 = a_1["default"].A2;

tests/baselines/reference/exportDefaultClodule.symbols

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/a.ts ===
+// https://github.com/Microsoft/TypeScript/issues/3792
+export default class A {
+>A : Symbol(A, Decl(a.ts, 0, 0), Decl(a.ts, 3, 1))
+
+    A1: string
+>A1 : Symbol(A.A1, Decl(a.ts, 1, 24))
+}
+export default namespace A {
+>A : Symbol(A, Decl(a.ts, 0, 0), Decl(a.ts, 3, 1))
+
+    export const A2 = 32;
+>A2 : Symbol(A2, Decl(a.ts, 5, 16))
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a";
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+const a = new A();
+>a : Symbol(a, Decl(b.ts, 2, 5))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+const a2 = A.A2;
+>a2 : Symbol(a2, Decl(b.ts, 3, 5))
+>A.A2 : Symbol(A.A2, Decl(a.ts, 5, 16))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+>A2 : Symbol(A.A2, Decl(a.ts, 5, 16))
+

tests/baselines/reference/exportDefaultClodule.types

@@ -0,0 +1,31 @@
+=== tests/cases/compiler/a.ts ===
+// https://github.com/Microsoft/TypeScript/issues/3792
+export default class A {
+>A : A
+
+    A1: string
+>A1 : string
+}
+export default namespace A {
+>A : typeof A
+
+    export const A2 = 32;
+>A2 : 32
+>32 : 32
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a";
+>A : typeof A
+
+const a = new A();
+>a : A
+>new A() : A
+>A : typeof A
+
+const a2 = A.A2;
+>a2 : 32
+>A.A2 : 32
+>A : typeof A
+>A2 : 32
+

tests/baselines/reference/exportDefaultCloduleWithDifferentNames.errors.txt

@@ -0,0 +1,17 @@
+tests/cases/compiler/a.ts(2,22): error TS2734: Merged default exports must have the same name.
+tests/cases/compiler/a.ts(5,26): error TS2734: Merged default exports must have the same name.
+
+
+==== tests/cases/compiler/a.ts (2 errors) ====
+    // https://github.com/Microsoft/TypeScript/issues/3792
+    export default class A {
+                         ~
+!!! error TS2734: Merged default exports must have the same name.
+        A1: string = "init"
+    }
+    export default namespace B {
+                             ~
+!!! error TS2734: Merged default exports must have the same name.
+        export const A2 = 32;
+    }
+    

tests/baselines/reference/exportDefaultCloduleWithDifferentNames.js

@@ -0,0 +1,25 @@
+//// [a.ts]
+// https://github.com/Microsoft/TypeScript/issues/3792
+export default class A {
+    A1: string = "init"
+}
+export default namespace B {
+    export const A2 = 32;
+}
+
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+// https://github.com/Microsoft/TypeScript/issues/3792
+var A = /** @class */ (function () {
+    function A() {
+        this.A1 = "init";
+    }
+    return A;
+}());
+exports["default"] = A;
+var B;
+(function (B) {
+    B.A2 = 32;
+})(B = exports.B || (exports.B = {}));

tests/baselines/reference/exportDefaultCloduleWithDifferentNames.symbols

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/a.ts ===
+// https://github.com/Microsoft/TypeScript/issues/3792
+export default class A {
+>A : Symbol(A, Decl(a.ts, 0, 0), Decl(a.ts, 3, 1))
+
+    A1: string = "init"
+>A1 : Symbol(A.A1, Decl(a.ts, 1, 24))
+}
+export default namespace B {
+>B : Symbol(A, Decl(a.ts, 0, 0), Decl(a.ts, 3, 1))
+
+    export const A2 = 32;
+>A2 : Symbol(A2, Decl(a.ts, 5, 16))
+}
+

tests/baselines/reference/exportDefaultCloduleWithDifferentNames.types

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/a.ts ===
+// https://github.com/Microsoft/TypeScript/issues/3792
+export default class A {
+>A : A
+
+    A1: string = "init"
+>A1 : string
+>"init" : "init"
+}
+export default namespace B {
+>B : typeof A
+
+    export const A2 = 32;
+>A2 : 32
+>32 : 32
+}
+

tests/baselines/reference/exportDefaultConstEnum.js

@@ -0,0 +1,23 @@
+//// [tests/cases/compiler/exportDefaultConstEnum.ts] ////
+
+//// [a.ts]
+// https://github.com/Microsoft/TypeScript/issues/3792
+export
+default
+const
+enum
+A
+{ FOO }
+
+//// [b.ts]
+import A from './a';
+
+const x = A.FOO;
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+//// [b.js]
+"use strict";
+exports.__esModule = true;
+var x = 0 /* FOO */;