feat(3792): Cannot 'export default' abstract, ambient class or interface

src/compiler/parser.ts

@@ -2822,12 +2822,27 @@ namespace Parser {
 
     function nextTokenCanFollowDefaultKeyword(): boolean {
         nextToken();
-        return token() === SyntaxKind.ClassKeyword
-            || token() === SyntaxKind.FunctionKeyword
-            || token() === SyntaxKind.InterfaceKeyword
-            || token() === SyntaxKind.AtToken
-            || (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:
+            case SyntaxKind.AtToken:
+                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
@@ -7142,6 +7157,18 @@ namespace Parser {
         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();

tests/baselines/reference/exportDefaultConstEnum.js

@@ -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";
+Object.defineProperty(exports, "__esModule", { value: true });
+//// [b.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+0 /* A.A */;
+1 /* A.B */;

tests/baselines/reference/exportDefaultConstEnum.symbols

@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/exportDefaultConstEnum.ts] ////
+
+=== 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))
+}
+
+=== 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.types

@@ -0,0 +1,37 @@
+//// [tests/cases/compiler/exportDefaultConstEnum.ts] ////
+
+=== a.ts ===
+export default const enum A {
+>A : A
+>  : ^
+
+    A,
+>A : A.A
+>  : ^^^
+
+    B
+>B : A.B
+>  : ^^^
+}
+
+=== 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/exportDefaultDeclareClass.js

@@ -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";
+Object.defineProperty(exports, "__esModule", { value: true });
+//// [b.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var a;
+a.foo;

tests/baselines/reference/exportDefaultDeclareClass.symbols

@@ -0,0 +1,23 @@
+//// [tests/cases/compiler/exportDefaultDeclareClass.ts] ////
+
+=== 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))
+}
+
+=== 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.types

@@ -0,0 +1,29 @@
+//// [tests/cases/compiler/exportDefaultDeclareClass.ts] ////
+
+=== a.ts ===
+export default declare class C {
+>C : C
+>  : ^
+
+    public foo: number;
+>foo : number
+>    : ^^^^^^
+}
+
+=== 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/exportDefaultEnum(module=amd,target=es5).js

@@ -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).symbols

@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/exportDefaultEnum.ts] ////
+
+=== 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))
+}
+
+=== 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))
+

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

@@ -0,0 +1,37 @@
+//// [tests/cases/compiler/exportDefaultEnum.ts] ////
+
+=== a.ts ===
+export default enum A {
+>A : A
+>  : ^
+
+    A,
+>A : A.A
+>  : ^^^
+
+    B
+>B : A.B
+>  : ^^^
+}
+
+=== 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/exportDefaultEnum(module=amd,target=esnext).js

@@ -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=esnext).symbols

@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/exportDefaultEnum.ts] ////
+
+=== 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))
+}
+
+=== 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))
+