feat(3792): allow export default namespaces/modules/enums/types/const/enums/declared classes

Author: a-tarasyuk

src/compiler/parser.ts

@@ -2168,10 +2168,26 @@ namespace ts {
 
         function nextTokenCanFollowDefaultKeyword(): 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.InterfaceKeyword:
+                case SyntaxKind.FunctionKeyword:
+                case SyntaxKind.NamespaceKeyword:
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.EnumKeyword:
+                case SyntaxKind.ConstKeyword:
+                    return true;
+                case SyntaxKind.DeclareKeyword:
+                    return lookAhead(nextTokenCanFollowExportDefaultDeclareKeyword);
+                case SyntaxKind.TypeKeyword:
+                    return lookAhead(nextTokenIsIdentifierOnSameLine);
+                case SyntaxKind.AbstractKeyword:
+                    return lookAhead(nextTokenIsClassKeywordOnSameLine);
+                case SyntaxKind.AsyncKeyword:
+                    return lookAhead(nextTokenIsFunctionKeywordOnSameLine);
+                default:
+                    return false;
+            }
         }
 
         // True if positioned at the start of a list element
@@ -6339,6 +6355,18 @@ namespace ts {
             return token() === SyntaxKind.ClassKeyword && !scanner.hasPrecedingLineBreak();
         }
 
+        function nextTokenCanFollowExportDefaultDeclareKeyword() {
+            nextToken();
+            switch (token()) {
+                case SyntaxKind.NamespaceKeyword:
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.ClassKeyword:
+                    return !scanner.hasPrecedingLineBreak();
+                default:
+                    return false;
+            }
+        }
+
         function nextTokenIsFunctionKeywordOnSameLine() {
             nextToken();
             return token() === SyntaxKind.FunctionKeyword && !scanner.hasPrecedingLineBreak();

src/compiler/transformers/ts.ts

@@ -0,0 +1,23 @@
+//// [tests/cases/compiler/exportDefaultConstEnum.ts] ////
+
+//// [a.ts]
+export default const enum A {
+    A,
+    B
+}
+
+//// [b.ts]
+import A from "./a"
+
+A.A;
+A.B;
+
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+//// [b.js]
+"use strict";
+exports.__esModule = true;
+0 /* A.A */;
+1 /* A.B */;

tests/baselines/reference/exportDefaultConstEnum.js

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/a.ts ===
+export default const enum A {
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+    A,
+>A : Symbol(A.A, Decl(a.ts, 0, 29))
+
+    B
+>B : Symbol(A.B, Decl(a.ts, 1, 6))
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a"
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+A.A;
+>A.A : Symbol(A.A, Decl(a.ts, 0, 29))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+>A : Symbol(A.A, Decl(a.ts, 0, 29))
+
+A.B;
+>A.B : Symbol(A.B, Decl(a.ts, 1, 6))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+>B : Symbol(A.B, Decl(a.ts, 1, 6))
+

tests/baselines/reference/exportDefaultConstEnum.symbols

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/a.ts ===
+export default const enum A {
+>A : A
+
+    A,
+>A : A.A
+
+    B
+>B : A.B
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a"
+>A : typeof A
+
+A.A;
+>A.A : A.A
+>A : typeof A
+>A : A.A
+
+A.B;
+>A.B : A.B
+>A : typeof A
+>B : A.B
+

tests/baselines/reference/exportDefaultConstEnum.types

@@ -0,0 +1,21 @@
+//// [tests/cases/compiler/exportDefaultDeclareClass.ts] ////
+
+//// [a.ts]
+export default declare class C {
+    public foo: number;
+}
+
+//// [b.ts]
+import A from "./a"
+let a: A;
+a.foo
+
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+//// [b.js]
+"use strict";
+exports.__esModule = true;
+var a;
+a.foo;

tests/baselines/reference/exportDefaultDeclareClass.js

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/a.ts ===
+export default declare class C {
+>C : Symbol(C, Decl(a.ts, 0, 0))
+
+    public foo: number;
+>foo : Symbol(C.foo, Decl(a.ts, 0, 32))
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a"
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+let a: A;
+>a : Symbol(a, Decl(b.ts, 1, 3))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+a.foo
+>a.foo : Symbol(A.foo, Decl(a.ts, 0, 32))
+>a : Symbol(a, Decl(b.ts, 1, 3))
+>foo : Symbol(A.foo, Decl(a.ts, 0, 32))
+

tests/baselines/reference/exportDefaultDeclareClass.symbols

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/a.ts ===
+export default declare class C {
+>C : C
+
+    public foo: number;
+>foo : number
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a"
+>A : typeof A
+
+let a: A;
+>a : A
+
+a.foo
+>a.foo : number
+>a : A
+>foo : number
+

tests/baselines/reference/exportDefaultDeclareClass.types

@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/exportDefaultEnum.ts] ////
+
+//// [a.ts]
+export default enum A {
+    A,
+    B
+}
+
+//// [b.ts]
+import A from "./a"
+
+A.A;
+A.B;
+
+
+//// [a.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var A = {};
+    exports.default = A;
+    (function (A) {
+        A[A["A"] = 0] = "A";
+        A[A["B"] = 1] = "B";
+    })(A);
+});
+//// [b.js]
+define(["require", "exports", "./a"], function (require, exports, a_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    a_1.default.A;
+    a_1.default.B;
+});

tests/baselines/reference/exportDefaultEnum(module=amd,target=es5).js

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/a.ts ===
+export default enum A {
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+    A,
+>A : Symbol(A.A, Decl(a.ts, 0, 23))
+
+    B
+>B : Symbol(A.B, Decl(a.ts, 1, 6))
+}
+
+=== tests/cases/compiler/b.ts ===
+import A from "./a"
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+A.A;
+>A.A : Symbol(A.A, Decl(a.ts, 0, 23))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+>A : Symbol(A.A, Decl(a.ts, 0, 23))
+
+A.B;
+>A.B : Symbol(A.B, Decl(a.ts, 1, 6))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+>B : Symbol(A.B, Decl(a.ts, 1, 6))
+