From f33c0fa072a2b6603fd155fe27401b691477cde4 Mon Sep 17 00:00:00 2001 From: DetachHead Date: Sat, 20 Nov 2021 04:20:30 +1000 Subject: [PATCH 1/5] fix issue where duplicate default exports aren't detected when there's an interface --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0dd0d1d6b4f3e..d03b24f6193cd 100644 --- a/src/compiler/checker.ts +++ b/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) From fdfdfd826ede046b4cb9da9db462837891661c36 Mon Sep 17 00:00:00 2001 From: DetachHead Date: Sat, 20 Nov 2021 14:11:19 +1000 Subject: [PATCH 2/5] accept baseline change --- .../exportDefaultInterfaceAndTwoFunctions.errors.txt | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/tests/baselines/reference/exportDefaultInterfaceAndTwoFunctions.errors.txt b/tests/baselines/reference/exportDefaultInterfaceAndTwoFunctions.errors.txt index 9f1f731b6a76c..7b057d28ec9ff 100644 --- a/tests/baselines/reference/exportDefaultInterfaceAndTwoFunctions.errors.txt +++ b/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. \ No newline at end of file From 3213d10f5e53c91af1c69aff8b07d4de8e7f4d81 Mon Sep 17 00:00:00 2001 From: DetachHead Date: Sat, 20 Nov 2021 14:19:20 +1000 Subject: [PATCH 3/5] add `exportDefaultInterfaceClassAndValue` test --- ...ortDefaultInterfaceClassAndValue.errors.txt | 17 +++++++++++++++++ .../exportDefaultInterfaceClassAndValue.js | 18 ++++++++++++++++++ ...exportDefaultInterfaceClassAndValue.symbols | 13 +++++++++++++ .../exportDefaultInterfaceClassAndValue.types | 13 +++++++++++++ .../exportDefaultInterfaceClassAndValue.ts | 4 ++++ 5 files changed, 65 insertions(+) create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndValue.errors.txt create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndValue.js create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndValue.symbols create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndValue.types create mode 100644 tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndValue.errors.txt b/tests/baselines/reference/exportDefaultInterfaceClassAndValue.errors.txt new file mode 100644 index 0000000000000..2630eca7c4dbe --- /dev/null +++ b/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'. + \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndValue.js b/tests/baselines/reference/exportDefaultInterfaceClassAndValue.js new file mode 100644 index 0000000000000..795b1a7688f46 --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndValue.symbols b/tests/baselines/reference/exportDefaultInterfaceClassAndValue.symbols new file mode 100644 index 0000000000000..6650f51f7b56b --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndValue.types b/tests/baselines/reference/exportDefaultInterfaceClassAndValue.types new file mode 100644 index 0000000000000..9180e17e8f474 --- /dev/null +++ b/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 {} + diff --git a/tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts b/tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts new file mode 100644 index 0000000000000..ae5d84ba1d8e5 --- /dev/null +++ b/tests/cases/compiler/exportDefaultInterfaceClassAndValue.ts @@ -0,0 +1,4 @@ +const foo = 1 +export default foo +export default class Foo {} +export default interface Foo {} From d478401a29fa1ab5c14bb169c139b9e5eb2b61b7 Mon Sep 17 00:00:00 2001 From: DetachHead Date: Sat, 29 Jan 2022 14:00:10 +1000 Subject: [PATCH 4/5] add more tests for multiple default exports --- .../exportDefaultClassAndValue.errors.txt | 13 ++++++++ .../reference/exportDefaultClassAndValue.js | 17 +++++++++++ .../exportDefaultClassAndValue.symbols | 10 +++++++ .../exportDefaultClassAndValue.types | 11 +++++++ ...ortDefaultInterfaceAndFunctionOverloads.js | 16 ++++++++++ ...faultInterfaceAndFunctionOverloads.symbols | 18 +++++++++++ ...DefaultInterfaceAndFunctionOverloads.types | 18 +++++++++++ ...erfaceClassAndFunctionOverloads.errors.txt | 30 +++++++++++++++++++ ...faultInterfaceClassAndFunctionOverloads.js | 19 ++++++++++++ ...InterfaceClassAndFunctionOverloads.symbols | 24 +++++++++++++++ ...ltInterfaceClassAndFunctionOverloads.types | 24 +++++++++++++++ .../exportDefaultTypeAndClass.errors.txt | 15 ++++++++++ .../reference/exportDefaultTypeAndClass.js | 15 ++++++++++ .../exportDefaultTypeAndClass.symbols | 10 +++++++ .../reference/exportDefaultTypeAndClass.types | 10 +++++++ ...DefaultTypeAndFunctionOverloads.errors.txt | 29 ++++++++++++++++++ .../exportDefaultTypeAndFunctionOverloads.js | 17 +++++++++++ ...ortDefaultTypeAndFunctionOverloads.symbols | 21 +++++++++++++ ...xportDefaultTypeAndFunctionOverloads.types | 22 ++++++++++++++ .../exportDefaultTypeClassAndValue.errors.txt | 28 +++++++++++++++++ .../exportDefaultTypeClassAndValue.js | 19 ++++++++++++ .../exportDefaultTypeClassAndValue.symbols | 16 ++++++++++ .../exportDefaultTypeClassAndValue.types | 17 +++++++++++ .../exportInterfaceClassAndValue.errors.txt | 13 ++++++++ .../reference/exportInterfaceClassAndValue.js | 11 +++++++ .../exportInterfaceClassAndValue.symbols | 10 +++++++ .../exportInterfaceClassAndValue.types | 10 +++++++ ...ValueWithDuplicatesInImportList.errors.txt | 15 ++++++++++ ...ClassAndValueWithDuplicatesInImportList.js | 20 +++++++++++++ ...AndValueWithDuplicatesInImportList.symbols | 15 ++++++++++ ...ssAndValueWithDuplicatesInImportList.types | 15 ++++++++++ .../compiler/exportDefaultClassAndValue.ts | 3 ++ ...ortDefaultInterfaceAndFunctionOverloads.ts | 6 ++++ ...faultInterfaceClassAndFunctionOverloads.ts | 8 +++++ .../compiler/exportDefaultTypeAndClass.ts | 3 ++ .../exportDefaultTypeAndFunctionOverloads.ts | 7 +++++ .../exportDefaultTypeClassAndValue.ts | 5 ++++ .../compiler/exportInterfaceClassAndValue.ts | 3 ++ ...ClassAndValueWithDuplicatesInImportList.ts | 5 ++++ 39 files changed, 568 insertions(+) create mode 100644 tests/baselines/reference/exportDefaultClassAndValue.errors.txt create mode 100644 tests/baselines/reference/exportDefaultClassAndValue.js create mode 100644 tests/baselines/reference/exportDefaultClassAndValue.symbols create mode 100644 tests/baselines/reference/exportDefaultClassAndValue.types create mode 100644 tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.js create mode 100644 tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.symbols create mode 100644 tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.types create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.errors.txt create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.js create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.symbols create mode 100644 tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.types create mode 100644 tests/baselines/reference/exportDefaultTypeAndClass.errors.txt create mode 100644 tests/baselines/reference/exportDefaultTypeAndClass.js create mode 100644 tests/baselines/reference/exportDefaultTypeAndClass.symbols create mode 100644 tests/baselines/reference/exportDefaultTypeAndClass.types create mode 100644 tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.errors.txt create mode 100644 tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.js create mode 100644 tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.symbols create mode 100644 tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types create mode 100644 tests/baselines/reference/exportDefaultTypeClassAndValue.errors.txt create mode 100644 tests/baselines/reference/exportDefaultTypeClassAndValue.js create mode 100644 tests/baselines/reference/exportDefaultTypeClassAndValue.symbols create mode 100644 tests/baselines/reference/exportDefaultTypeClassAndValue.types create mode 100644 tests/baselines/reference/exportInterfaceClassAndValue.errors.txt create mode 100644 tests/baselines/reference/exportInterfaceClassAndValue.js create mode 100644 tests/baselines/reference/exportInterfaceClassAndValue.symbols create mode 100644 tests/baselines/reference/exportInterfaceClassAndValue.types create mode 100644 tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.errors.txt create mode 100644 tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.js create mode 100644 tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.symbols create mode 100644 tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.types create mode 100644 tests/cases/compiler/exportDefaultClassAndValue.ts create mode 100644 tests/cases/compiler/exportDefaultInterfaceAndFunctionOverloads.ts create mode 100644 tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts create mode 100644 tests/cases/compiler/exportDefaultTypeAndClass.ts create mode 100644 tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts create mode 100644 tests/cases/compiler/exportDefaultTypeClassAndValue.ts create mode 100644 tests/cases/compiler/exportInterfaceClassAndValue.ts create mode 100644 tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts diff --git a/tests/baselines/reference/exportDefaultClassAndValue.errors.txt b/tests/baselines/reference/exportDefaultClassAndValue.errors.txt new file mode 100644 index 0000000000000..77beaef3d1949 --- /dev/null +++ b/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'. + \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultClassAndValue.js b/tests/baselines/reference/exportDefaultClassAndValue.js new file mode 100644 index 0000000000000..84f23fa9ece18 --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultClassAndValue.symbols b/tests/baselines/reference/exportDefaultClassAndValue.symbols new file mode 100644 index 0000000000000..f4d006576a152 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultClassAndValue.types b/tests/baselines/reference/exportDefaultClassAndValue.types new file mode 100644 index 0000000000000..036eb93bd0e05 --- /dev/null +++ b/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 + diff --git a/tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.js b/tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.js new file mode 100644 index 0000000000000..18e9a05ca564b --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.symbols b/tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.symbols new file mode 100644 index 0000000000000..24698bd222049 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.types b/tests/baselines/reference/exportDefaultInterfaceAndFunctionOverloads.types new file mode 100644 index 0000000000000..d92d7e083107f --- /dev/null +++ b/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 {} + diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.errors.txt b/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.errors.txt new file mode 100644 index 0000000000000..a59fa46a68756 --- /dev/null +++ b/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 {} + \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.js b/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.js new file mode 100644 index 0000000000000..74bfe8d2efdfc --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.symbols b/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.symbols new file mode 100644 index 0000000000000..df95cef283ed5 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.types b/tests/baselines/reference/exportDefaultInterfaceClassAndFunctionOverloads.types new file mode 100644 index 0000000000000..7d527120b2855 --- /dev/null +++ b/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 {} + diff --git a/tests/baselines/reference/exportDefaultTypeAndClass.errors.txt b/tests/baselines/reference/exportDefaultTypeAndClass.errors.txt new file mode 100644 index 0000000000000..6602907511445 --- /dev/null +++ b/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. + \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultTypeAndClass.js b/tests/baselines/reference/exportDefaultTypeAndClass.js new file mode 100644 index 0000000000000..90ef1136a5cc0 --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultTypeAndClass.symbols b/tests/baselines/reference/exportDefaultTypeAndClass.symbols new file mode 100644 index 0000000000000..f461eb50ca03c --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultTypeAndClass.types b/tests/baselines/reference/exportDefaultTypeAndClass.types new file mode 100644 index 0000000000000..273a650257c5e --- /dev/null +++ b/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 + diff --git a/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.errors.txt b/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.errors.txt new file mode 100644 index 0000000000000..0e9d3b1b814d0 --- /dev/null +++ b/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. + \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.js b/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.js new file mode 100644 index 0000000000000..8758374589089 --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.symbols b/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.symbols new file mode 100644 index 0000000000000..5c09cc3718bf3 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types b/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types new file mode 100644 index 0000000000000..c014cddfa250e --- /dev/null +++ b/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 + diff --git a/tests/baselines/reference/exportDefaultTypeClassAndValue.errors.txt b/tests/baselines/reference/exportDefaultTypeClassAndValue.errors.txt new file mode 100644 index 0000000000000..396271376f6e7 --- /dev/null +++ b/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. + \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultTypeClassAndValue.js b/tests/baselines/reference/exportDefaultTypeClassAndValue.js new file mode 100644 index 0000000000000..18a60bfb6f6b6 --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportDefaultTypeClassAndValue.symbols b/tests/baselines/reference/exportDefaultTypeClassAndValue.symbols new file mode 100644 index 0000000000000..4852fd5ef9bd2 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportDefaultTypeClassAndValue.types b/tests/baselines/reference/exportDefaultTypeClassAndValue.types new file mode 100644 index 0000000000000..2896db94a5ebb --- /dev/null +++ b/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 + diff --git a/tests/baselines/reference/exportInterfaceClassAndValue.errors.txt b/tests/baselines/reference/exportInterfaceClassAndValue.errors.txt new file mode 100644 index 0000000000000..cd971f7157bd8 --- /dev/null +++ b/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 {} + \ No newline at end of file diff --git a/tests/baselines/reference/exportInterfaceClassAndValue.js b/tests/baselines/reference/exportInterfaceClassAndValue.js new file mode 100644 index 0000000000000..2ad0c983f16d5 --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportInterfaceClassAndValue.symbols b/tests/baselines/reference/exportInterfaceClassAndValue.symbols new file mode 100644 index 0000000000000..90580910a8df0 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportInterfaceClassAndValue.types b/tests/baselines/reference/exportInterfaceClassAndValue.types new file mode 100644 index 0000000000000..b4a75da6c6e00 --- /dev/null +++ b/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 {} + diff --git a/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.errors.txt b/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.errors.txt new file mode 100644 index 0000000000000..6c145b09f9e69 --- /dev/null +++ b/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'. + \ No newline at end of file diff --git a/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.js b/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.js new file mode 100644 index 0000000000000..6aa35e13f3c1a --- /dev/null +++ b/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; diff --git a/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.symbols b/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.symbols new file mode 100644 index 0000000000000..74f3434f0dd8b --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.types b/tests/baselines/reference/exportInterfaceClassAndValueWithDuplicatesInImportList.types new file mode 100644 index 0000000000000..313eb1f1af4fd --- /dev/null +++ b/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 + diff --git a/tests/cases/compiler/exportDefaultClassAndValue.ts b/tests/cases/compiler/exportDefaultClassAndValue.ts new file mode 100644 index 0000000000000..3a18018620950 --- /dev/null +++ b/tests/cases/compiler/exportDefaultClassAndValue.ts @@ -0,0 +1,3 @@ +const foo = 1 +export default foo +export default class Foo {} diff --git a/tests/cases/compiler/exportDefaultInterfaceAndFunctionOverloads.ts b/tests/cases/compiler/exportDefaultInterfaceAndFunctionOverloads.ts new file mode 100644 index 0000000000000..7296b02464420 --- /dev/null +++ b/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 {} diff --git a/tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts b/tests/cases/compiler/exportDefaultInterfaceClassAndFunctionOverloads.ts new file mode 100644 index 0000000000000..18bca0a62fcb9 --- /dev/null +++ b/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 {} diff --git a/tests/cases/compiler/exportDefaultTypeAndClass.ts b/tests/cases/compiler/exportDefaultTypeAndClass.ts new file mode 100644 index 0000000000000..cf26cb35cbe35 --- /dev/null +++ b/tests/cases/compiler/exportDefaultTypeAndClass.ts @@ -0,0 +1,3 @@ +export default class Foo {} +type Bar = {} +export default Bar diff --git a/tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts b/tests/cases/compiler/exportDefaultTypeAndFunctionOverloads.ts new file mode 100644 index 0000000000000..da1422fbb56a7 --- /dev/null +++ b/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 diff --git a/tests/cases/compiler/exportDefaultTypeClassAndValue.ts b/tests/cases/compiler/exportDefaultTypeClassAndValue.ts new file mode 100644 index 0000000000000..39ca741d6d17c --- /dev/null +++ b/tests/cases/compiler/exportDefaultTypeClassAndValue.ts @@ -0,0 +1,5 @@ +const foo = 1 +export default foo +export default class Foo {} +type Bar = {} +export default Bar diff --git a/tests/cases/compiler/exportInterfaceClassAndValue.ts b/tests/cases/compiler/exportInterfaceClassAndValue.ts new file mode 100644 index 0000000000000..fc29df8faad76 --- /dev/null +++ b/tests/cases/compiler/exportInterfaceClassAndValue.ts @@ -0,0 +1,3 @@ +export const foo = 1 +export declare class foo {} +export interface foo {} diff --git a/tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts b/tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts new file mode 100644 index 0000000000000..8edd59e19a1f4 --- /dev/null +++ b/tests/cases/compiler/exportInterfaceClassAndValueWithDuplicatesInImportList.ts @@ -0,0 +1,5 @@ +const foo = 1 +class Foo {} +interface Foo {} + +export {foo, Foo, Foo} From 9f7ba44b088a29bdd12dd04cb772d4eb3aef6676 Mon Sep 17 00:00:00 2001 From: DetachHead Date: Fri, 4 Feb 2022 00:04:24 +1000 Subject: [PATCH 5/5] add two interfaces test --- .../reference/exportTwoInterfacesWithSameName.js | 8 ++++++++ .../reference/exportTwoInterfacesWithSameName.symbols | 7 +++++++ .../reference/exportTwoInterfacesWithSameName.types | 5 +++++ tests/cases/compiler/exportTwoInterfacesWithSameName.ts | 2 ++ 4 files changed, 22 insertions(+) create mode 100644 tests/baselines/reference/exportTwoInterfacesWithSameName.js create mode 100644 tests/baselines/reference/exportTwoInterfacesWithSameName.symbols create mode 100644 tests/baselines/reference/exportTwoInterfacesWithSameName.types create mode 100644 tests/cases/compiler/exportTwoInterfacesWithSameName.ts diff --git a/tests/baselines/reference/exportTwoInterfacesWithSameName.js b/tests/baselines/reference/exportTwoInterfacesWithSameName.js new file mode 100644 index 0000000000000..06ae4b99a7e93 --- /dev/null +++ b/tests/baselines/reference/exportTwoInterfacesWithSameName.js @@ -0,0 +1,8 @@ +//// [exportTwoInterfacesWithSameName.ts] +export interface I {} +export interface I {} + + +//// [exportTwoInterfacesWithSameName.js] +"use strict"; +exports.__esModule = true; diff --git a/tests/baselines/reference/exportTwoInterfacesWithSameName.symbols b/tests/baselines/reference/exportTwoInterfacesWithSameName.symbols new file mode 100644 index 0000000000000..4555053e70ec5 --- /dev/null +++ b/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)) + diff --git a/tests/baselines/reference/exportTwoInterfacesWithSameName.types b/tests/baselines/reference/exportTwoInterfacesWithSameName.types new file mode 100644 index 0000000000000..4865183ebc889 --- /dev/null +++ b/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. \ No newline at end of file diff --git a/tests/cases/compiler/exportTwoInterfacesWithSameName.ts b/tests/cases/compiler/exportTwoInterfacesWithSameName.ts new file mode 100644 index 0000000000000..4f502f99ef1ca --- /dev/null +++ b/tests/cases/compiler/exportTwoInterfacesWithSameName.ts @@ -0,0 +1,2 @@ +export interface I {} +export interface I {}