fix issue where duplicate default exports aren't detected

src/compiler/checker.ts

@@ -40095,10 +40095,10 @@ namespace ts {
                         }
                         // ECMA262: 15.2.1.1 It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries.
                         // (TS Exceptions: namespaces, function overloads, enums, and interfaces)
-                        if (flags & (SymbolFlags.Namespace | SymbolFlags.Interface | SymbolFlags.Enum)) {
+                        if (flags & (SymbolFlags.Namespace | SymbolFlags.Enum)) {
                             return;
                         }
-                        const exportedDeclarationsCount = countWhere(declarations, isNotOverloadAndNotAccessor);
+                        const exportedDeclarationsCount = countWhere(declarations, and(isNotOverloadAndNotAccessor, not(isInterfaceDeclaration)));
                         if (flags & SymbolFlags.TypeAlias && exportedDeclarationsCount <= 2) {
                             // it is legal to merge type alias with other values
                             // so count should be either 1 (just type alias) or 2 (type alias + merged value)

tests/baselines/reference/exportDefaultClassAndValue.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/compiler/exportDefaultClassAndValue.ts(2,1): error TS2323: Cannot redeclare exported variable 'default'.
+tests/cases/compiler/exportDefaultClassAndValue.ts(3,22): error TS2323: Cannot redeclare exported variable 'default'.
+
+
+==== tests/cases/compiler/exportDefaultClassAndValue.ts (2 errors) ====
+    const foo = 1
+    export default foo
+    ~~~~~~~~~~~~~~~~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+    export default class Foo {}
+                         ~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+

tests/baselines/reference/exportDefaultClassAndValue.js

@@ -0,0 +1,17 @@
+//// [exportDefaultClassAndValue.ts]
+const foo = 1
+export default foo
+export default class Foo {}
+
+
+//// [exportDefaultClassAndValue.js]
+"use strict";
+exports.__esModule = true;
+var foo = 1;
+exports["default"] = foo;
+var Foo = /** @class */ (function () {
+    function Foo() {
+    }
+    return Foo;
+}());
+exports["default"] = Foo;

tests/baselines/reference/exportDefaultClassAndValue.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/exportDefaultClassAndValue.ts ===
+const foo = 1
+>foo : Symbol(foo, Decl(exportDefaultClassAndValue.ts, 0, 5))
+
+export default foo
+>foo : Symbol(foo, Decl(exportDefaultClassAndValue.ts, 0, 5))
+
+export default class Foo {}
+>Foo : Symbol(foo, Decl(exportDefaultClassAndValue.ts, 0, 13), Decl(exportDefaultClassAndValue.ts, 1, 18))
+

tests/baselines/reference/exportDefaultClassAndValue.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/exportDefaultClassAndValue.ts ===
+const foo = 1
+>foo : 1
+>1 : 1
+
+export default foo
+>foo : 1
+
+export default class Foo {}
+>Foo : foo
+

tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.js

@@ -0,0 +1,16 @@
+//// [exportDefaultInterfaceAndFunctionOverloads.ts]
+export default function foo(value: number): number
+export default function foo(value: string): string
+export default function foo(value: string | number): string | number {
+    return 1
+}
+export default interface Foo {}
+
+
+//// [exportDefaultInterfaceAndFunctionOverloads.js]
+"use strict";
+exports.__esModule = true;
+function foo(value) {
+    return 1;
+}
+exports["default"] = foo;

tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.symbols

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/exportDefaultInterfaceAndFunctionOverloads.ts ===
+export default function foo(value: number): number
+>foo : Symbol(foo, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 4, 1))
+>value : Symbol(value, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 28))
+
+export default function foo(value: string): string
+>foo : Symbol(foo, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 4, 1))
+>value : Symbol(value, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 1, 28))
+
+export default function foo(value: string | number): string | number {
+>foo : Symbol(foo, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 4, 1))
+>value : Symbol(value, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 2, 28))
+
+    return 1
+}
+export default interface Foo {}
+>Foo : Symbol(foo, Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceAndFunctionOverloads.ts, 4, 1))
+

tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.types

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/exportDefaultInterfaceAndFunctionOverloads.ts ===
+export default function foo(value: number): number
+>foo : { (value: number): number; (value: string): string; }
+>value : number
+
+export default function foo(value: string): string
+>foo : { (value: number): number; (value: string): string; }
+>value : string
+
+export default function foo(value: string | number): string | number {
+>foo : { (value: number): number; (value: string): string; }
+>value : string | number
+
+    return 1
+>1 : 1
+}
+export default interface Foo {}
+

tests/baselines/reference/exportDefaultInterfaceAndTwoFunctions.errors.txt

@@ -1,13 +1,22 @@
+tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts(1,26): error TS2323: Cannot redeclare exported variable 'default'.
+tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts(2,1): error TS2323: Cannot redeclare exported variable 'default'.
 tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts(2,1): error TS2393: Duplicate function implementation.
+tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts(3,1): error TS2323: Cannot redeclare exported variable 'default'.
 tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts(3,1): error TS2393: Duplicate function implementation.
 
 
-==== tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts (2 errors) ====
+==== tests/cases/compiler/exportDefaultInterfaceAndTwoFunctions.ts (5 errors) ====
     export default interface A { a: string; }
+                             ~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
     export default function() { return 1; }
     ~~~~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+    ~~~~~~
 !!! error TS2393: Duplicate function implementation.
     export default function() { return 2; }
     ~~~~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+    ~~~~~~
 !!! error TS2393: Duplicate function implementation.
 

tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.errors.txt

@@ -0,0 +1,30 @@
+tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts(1,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts(2,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts(3,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts(7,16): error TS2528: A module cannot have multiple default exports.
+
+
+==== tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts (4 errors) ====
+    export default function foo(value: number): number
+                            ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2753 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts:7:16: Another export default is here.
+    export default function foo(value: string): string
+                            ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS6204 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts:7:16: and here.
+    export default function foo(value: string | number): string | number {
+                            ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS6204 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts:7:16: and here.
+        return 1
+    }
+    declare class Foo {}
+    export default Foo
+                   ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2752 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts:1:25: The first export default is here.
+!!! related TS2752 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts:2:25: The first export default is here.
+!!! related TS2752 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts:3:25: The first export default is here.
+    export default interface Bar {}
+

tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.js

@@ -0,0 +1,19 @@
+//// [exportDefaultInterfaceClassAndFunctionOverloads.ts]
+export default function foo(value: number): number
+export default function foo(value: string): string
+export default function foo(value: string | number): string | number {
+    return 1
+}
+declare class Foo {}
+export default Foo
+export default interface Bar {}
+
+
+//// [exportDefaultInterfaceClassAndFunctionOverloads.js]
+"use strict";
+exports.__esModule = true;
+function foo(value) {
+    return 1;
+}
+exports["default"] = foo;
+exports["default"] = Foo;

tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts ===
+export default function foo(value: number): number
+>foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 6, 18))
+>value : Symbol(value, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 28))
+
+export default function foo(value: string): string
+>foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 6, 18))
+>value : Symbol(value, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 1, 28))
+
+export default function foo(value: string | number): string | number {
+>foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 6, 18))
+>value : Symbol(value, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 2, 28))
+
+    return 1
+}
+declare class Foo {}
+>Foo : Symbol(Foo, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 4, 1))
+
+export default Foo
+>Foo : Symbol(Foo, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 4, 1))
+
+export default interface Bar {}
+>Bar : Symbol(foo, Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 0), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 0, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 1, 50), Decl(exportDefaultInterfaceClassAndFunctionOverloads.ts, 6, 18))
+

tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.types

@@ -0,0 +1,24 @@
+=== tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts ===
+export default function foo(value: number): number
+>foo : { (value: number): number; (value: string): string; }
+>value : number
+
+export default function foo(value: string): string
+>foo : { (value: number): number; (value: string): string; }
+>value : string
+
+export default function foo(value: string | number): string | number {
+>foo : { (value: number): number; (value: string): string; }
+>value : string | number
+
+    return 1
+>1 : 1
+}
+declare class Foo {}
+>Foo : Foo
+
+export default Foo
+>Foo : Foo
+
+export default interface Bar {}
+

tests/baselines/reference/exportDefaultInterfaceClassAndValue.errors.txt

@@ -0,0 +1,17 @@
+tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts(2,1): error TS2323: Cannot redeclare exported variable 'default'.
+tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts(3,22): error TS2323: Cannot redeclare exported variable 'default'.
+tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts(4,26): error TS2323: Cannot redeclare exported variable 'default'.
+
+
+==== tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts (3 errors) ====
+    const foo = 1
+    export default foo
+    ~~~~~~~~~~~~~~~~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+    export default class Foo {}
+                         ~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+    export default interface Foo {}
+                             ~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+

tests/baselines/reference/exportDefaultInterfaceClassAndValue.js

@@ -0,0 +1,18 @@
+//// [exportDefaultInterfaceClassAndValue.ts]
+const foo = 1
+export default foo
+export default class Foo {}
+export default interface Foo {}
+
+
+//// [exportDefaultInterfaceClassAndValue.js]
+"use strict";
+exports.__esModule = true;
+var foo = 1;
+exports["default"] = foo;
+var Foo = /** @class */ (function () {
+    function Foo() {
+    }
+    return Foo;
+}());
+exports["default"] = Foo;

tests/baselines/reference/exportDefaultInterfaceClassAndValue.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts ===
+const foo = 1
+>foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndValue.ts, 0, 5))
+
+export default foo
+>foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndValue.ts, 0, 5))
+
+export default class Foo {}
+>Foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndValue.ts, 0, 13), Decl(exportDefaultInterfaceClassAndValue.ts, 1, 18), Decl(exportDefaultInterfaceClassAndValue.ts, 2, 27))
+
+export default interface Foo {}
+>Foo : Symbol(foo, Decl(exportDefaultInterfaceClassAndValue.ts, 0, 13), Decl(exportDefaultInterfaceClassAndValue.ts, 1, 18), Decl(exportDefaultInterfaceClassAndValue.ts, 2, 27))
+

tests/baselines/reference/exportDefaultInterfaceClassAndValue.types

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts ===
+const foo = 1
+>foo : 1
+>1 : 1
+
+export default foo
+>foo : 1
+
+export default class Foo {}
+>Foo : foo
+
+export default interface Foo {}
+

tests/baselines/reference/exportDefaultTypeAndClass.errors.txt

@@ -0,0 +1,15 @@
+tests/cases/compiler/exportDefaultTypeAndClass.ts(1,22): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultTypeAndClass.ts(3,16): error TS2528: A module cannot have multiple default exports.
+
+
+==== tests/cases/compiler/exportDefaultTypeAndClass.ts (2 errors) ====
+    export default class Foo {}
+                         ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2753 tests/cases/compiler/exportDefaultTypeAndClass.ts:3:16: Another export default is here.
+    type Bar = {}
+    export default Bar
+                   ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2752 tests/cases/compiler/exportDefaultTypeAndClass.ts:1:22: The first export default is here.
+

tests/baselines/reference/exportDefaultTypeAndClass.js

@@ -0,0 +1,15 @@
+//// [exportDefaultTypeAndClass.ts]
+export default class Foo {}
+type Bar = {}
+export default Bar
+
+
+//// [exportDefaultTypeAndClass.js]
+"use strict";
+exports.__esModule = true;
+var Foo = /** @class */ (function () {
+    function Foo() {
+    }
+    return Foo;
+}());
+exports["default"] = Foo;

tests/baselines/reference/exportDefaultTypeAndClass.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/exportDefaultTypeAndClass.ts ===
+export default class Foo {}
+>Foo : Symbol(Foo, Decl(exportDefaultTypeAndClass.ts, 0, 0))
+
+type Bar = {}
+>Bar : Symbol(Bar, Decl(exportDefaultTypeAndClass.ts, 0, 27))
+
+export default Bar
+>Bar : Symbol(Bar, Decl(exportDefaultTypeAndClass.ts, 0, 27))
+

tests/baselines/reference/exportDefaultTypeAndClass.types

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/exportDefaultTypeAndClass.ts ===
+export default class Foo {}
+>Foo : Foo
+
+type Bar = {}
+>Bar : Bar
+
+export default Bar
+>Bar : Bar
+