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