fix issue where duplicate default exports aren't detected (#46871)

* fix issue where duplicate default exports aren't detected when there's an interface

* accept baseline change

* add `exportDefaultInterfaceClassAndValue` test

* add more tests for multiple default exports

* add two interfaces test

Co-authored-by: DetachHead <detachhead@users.noreply.github.com>

src/compiler/checker.ts

@@ -40449,10 +40449,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
+

tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.errors.txt

@@ -0,0 +1,29 @@
+tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts(1,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts(2,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts(3,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts(7,16): error TS2528: A module cannot have multiple default exports.
+
+
+==== tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts (4 errors) ====
+    export default function foo(value: number): number
+                            ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2753 tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.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/exportDefaultTypeAndFunctionOverloads.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/exportDefaultTypeAndFunctionOverloads.ts:7:16: and here.
+        return 1
+    }
+    type Foo = {}
+    export default Foo
+                   ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2752 tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts:1:25: The first export default is here.
+!!! related TS2752 tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts:2:25: The first export default is here.
+!!! related TS2752 tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts:3:25: The first export default is here.
+    

tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.js

@@ -0,0 +1,17 @@
+//// [exportDefaultTypeAndFunctionOverloads.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
+}
+type Foo = {}
+export default Foo
+
+
+//// [exportDefaultTypeAndFunctionOverloads.js]
+"use strict";
+exports.__esModule = true;
+function foo(value) {
+    return 1;
+}
+exports["default"] = foo;

tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.symbols

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

tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.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
+}
+type Foo = {}
+>Foo : Foo
+
+export default Foo
+>Foo : Foo
+

tests/baselines/reference/exportDefaultTypeClassAndValue.errors.txt

@@ -0,0 +1,28 @@
+tests/cases/compiler/exportDefaultTypeClassAndValue.ts(2,1): error TS2323: Cannot redeclare exported variable 'default'.
+tests/cases/compiler/exportDefaultTypeClassAndValue.ts(2,16): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultTypeClassAndValue.ts(3,22): error TS2323: Cannot redeclare exported variable 'default'.
+tests/cases/compiler/exportDefaultTypeClassAndValue.ts(3,22): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/exportDefaultTypeClassAndValue.ts(5,16): error TS2528: A module cannot have multiple default exports.
+
+
+==== tests/cases/compiler/exportDefaultTypeClassAndValue.ts (5 errors) ====
+    const foo = 1
+    export default foo
+    ~~~~~~~~~~~~~~~~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+                   ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2753 tests/cases/compiler/exportDefaultTypeClassAndValue.ts:5:16: Another export default is here.
+    export default class Foo {}
+                         ~~~
+!!! error TS2323: Cannot redeclare exported variable 'default'.
+                         ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS6204 tests/cases/compiler/exportDefaultTypeClassAndValue.ts:5:16: and here.
+    type Bar = {}
+    export default Bar
+                   ~~~
+!!! error TS2528: A module cannot have multiple default exports.
+!!! related TS2752 tests/cases/compiler/exportDefaultTypeClassAndValue.ts:2:16: The first export default is here.
+!!! related TS2752 tests/cases/compiler/exportDefaultTypeClassAndValue.ts:3:22: The first export default is here.
+    

tests/baselines/reference/exportDefaultTypeClassAndValue.js

@@ -0,0 +1,19 @@
+//// [exportDefaultTypeClassAndValue.ts]
+const foo = 1
+export default foo
+export default class Foo {}
+type Bar = {}
+export default Bar
+
+
+//// [exportDefaultTypeClassAndValue.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/exportDefaultTypeClassAndValue.symbols

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

tests/baselines/reference/exportDefaultTypeClassAndValue.types

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/exportDefaultTypeClassAndValue.ts ===
+const foo = 1
+>foo : 1
+>1 : 1
+
+export default foo
+>foo : 1
+
+export default class Foo {}
+>Foo : foo
+
+type Bar = {}
+>Bar : Bar
+
+export default Bar
+>Bar : Bar
+

tests/baselines/reference/exportInterfaceClassAndValue.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/compiler/exportInterfaceClassAndValue.ts(1,14): error TS2451: Cannot redeclare block-scoped variable 'foo'.
+tests/cases/compiler/exportInterfaceClassAndValue.ts(2,22): error TS2451: Cannot redeclare block-scoped variable 'foo'.
+
+
+==== tests/cases/compiler/exportInterfaceClassAndValue.ts (2 errors) ====
+    export const foo = 1
+                 ~~~
+!!! error TS2451: Cannot redeclare block-scoped variable 'foo'.
+    export declare class foo {}
+                         ~~~
+!!! error TS2451: Cannot redeclare block-scoped variable 'foo'.
+    export interface foo {}
+    

tests/baselines/reference/exportInterfaceClassAndValue.js

@@ -0,0 +1,11 @@
+//// [exportInterfaceClassAndValue.ts]
+export const foo = 1
+export declare class foo {}
+export interface foo {}
+
+
+//// [exportInterfaceClassAndValue.js]
+"use strict";
+exports.__esModule = true;
+exports.foo = void 0;
+exports.foo = 1;

tests/baselines/reference/exportInterfaceClassAndValue.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/exportInterfaceClassAndValue.ts ===
+export const foo = 1
+>foo : Symbol(foo, Decl(exportInterfaceClassAndValue.ts, 0, 12), Decl(exportInterfaceClassAndValue.ts, 1, 27))
+
+export declare class foo {}
+>foo : Symbol(foo, Decl(exportInterfaceClassAndValue.ts, 0, 20))
+
+export interface foo {}
+>foo : Symbol(foo, Decl(exportInterfaceClassAndValue.ts, 0, 12), Decl(exportInterfaceClassAndValue.ts, 1, 27))
+

tests/baselines/reference/exportInterfaceClassAndValue.types

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/exportInterfaceClassAndValue.ts ===
+export const foo = 1
+>foo : 1
+>1 : 1
+
+export declare class foo {}
+>foo : import("tests/cases/compiler/exportInterfaceClassAndValue").foo
+
+export interface foo {}
+

tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.errors.txt

@@ -0,0 +1,15 @@
+tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts(5,14): error TS2300: Duplicate identifier 'Foo'.
+tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts(5,19): error TS2300: Duplicate identifier 'Foo'.
+
+
+==== tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts (2 errors) ====
+    const foo = 1
+    class Foo {}
+    interface Foo {}
+    
+    export {foo, Foo, Foo}
+                 ~~~
+!!! error TS2300: Duplicate identifier 'Foo'.
+                      ~~~
+!!! error TS2300: Duplicate identifier 'Foo'.
+    

tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.js

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

tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.symbols

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts ===
+const foo = 1
+>foo : Symbol(foo, Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 0, 5))
+
+class Foo {}
+>Foo : Symbol(Foo, Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 0, 13), Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 1, 12))
+
+interface Foo {}
+>Foo : Symbol(Foo, Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 0, 13), Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 1, 12))
+
+export {foo, Foo, Foo}
+>foo : Symbol(foo, Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 4, 8))
+>Foo : Symbol(Foo, Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 4, 12))
+>Foo : Symbol(Foo, Decl(exportInterfaceClassAndValueWithDuplicatesInImportList.ts, 4, 17))
+

tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.types

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts ===
+const foo = 1
+>foo : 1
+>1 : 1
+
+class Foo {}
+>Foo : Foo
+
+interface Foo {}
+
+export {foo, Foo, Foo}
+>foo : 1
+>Foo : typeof Foo
+>Foo : typeof Foo
+

tests/baselines/reference/exportTwoInterfacesWithSameName.js

@@ -0,0 +1,8 @@
+//// [exportTwoInterfacesWithSameName.ts]
+export interface I {}
+export interface I {}
+
+
+//// [exportTwoInterfacesWithSameName.js]
+"use strict";
+exports.__esModule = true;

tests/baselines/reference/exportTwoInterfacesWithSameName.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/exportTwoInterfacesWithSameName.ts ===
+export interface I {}
+>I : Symbol(I, Decl(exportTwoInterfacesWithSameName.ts, 0, 0), Decl(exportTwoInterfacesWithSameName.ts, 0, 21))
+
+export interface I {}
+>I : Symbol(I, Decl(exportTwoInterfacesWithSameName.ts, 0, 0), Decl(exportTwoInterfacesWithSameName.ts, 0, 21))
+

tests/baselines/reference/exportTwoInterfacesWithSameName.types

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/exportTwoInterfacesWithSameName.ts ===
+export interface I {}
+No type information for this code.export interface I {}
+No type information for this code.
+No type information for this code.

tests/cases/compiler/exportDefaultClassAndValue.ts

@@ -0,0 +1,3 @@
+const foo = 1
+export default foo
+export default class Foo {}

tests/cases/compiler/exportDefaultInterfaceAndFunctionOverloads.ts

@@ -0,0 +1,6 @@
+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 {}

tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts

@@ -0,0 +1,8 @@
+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 {}

tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts

@@ -0,0 +1,4 @@
+const foo = 1
+export default foo
+export default class Foo {}
+export default interface Foo {}

tests/cases/compiler/exportDefaultTypeAndClass.ts

@@ -0,0 +1,3 @@
+export default class Foo {}
+type Bar = {}
+export default Bar

tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts

@@ -0,0 +1,7 @@
+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
+}
+type Foo = {}
+export default Foo

tests/cases/compiler/exportDefaultTypeClassAndValue.ts

@@ -0,0 +1,5 @@
+const foo = 1
+export default foo
+export default class Foo {}
+type Bar = {}
+export default Bar

tests/cases/compiler/exportInterfaceClassAndValue.ts

@@ -0,0 +1,3 @@
+export const foo = 1
+export declare class foo {}
+export interface foo {}

tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts

@@ -0,0 +1,5 @@
+const foo = 1
+class Foo {}
+interface Foo {}
+
+export {foo, Foo, Foo}

tests/cases/compiler/exportTwoInterfacesWithSameName.ts

@@ -0,0 +1,2 @@
+export interface I {}
+export interface I {}