From c710b9621fb4d2665538002bed10aec520c65065 Mon Sep 17 00:00:00 2001 From: Lawrence Craft Date: Thu, 16 Jun 2022 10:06:07 +0100 Subject: [PATCH 1/3] Add case to capture enum subtype reduction (addresses #35867) Signed-off-by: Lawrence Craft --- .../reference/enumMemberReduction.js | 70 +++++++++++++++ .../reference/enumMemberReduction.symbols | 87 ++++++++++++++++++ .../reference/enumMemberReduction.types | 90 +++++++++++++++++++ tests/cases/compiler/enumMemberReduction.ts | 32 +++++++ 4 files changed, 279 insertions(+) create mode 100644 tests/baselines/reference/enumMemberReduction.js create mode 100644 tests/baselines/reference/enumMemberReduction.symbols create mode 100644 tests/baselines/reference/enumMemberReduction.types create mode 100644 tests/cases/compiler/enumMemberReduction.ts diff --git a/tests/baselines/reference/enumMemberReduction.js b/tests/baselines/reference/enumMemberReduction.js new file mode 100644 index 0000000000000..d2a2afcbbc0af --- /dev/null +++ b/tests/baselines/reference/enumMemberReduction.js @@ -0,0 +1,70 @@ +//// [enumMemberReduction.ts] +enum MyEnum { + A, + B, + C, +} + +enum MyStringEnum { + A = "a", + B = "b", + C = "c", +} + +export function fn(optionalEnum: MyEnum | undefined) { + return optionalEnum ?? MyEnum.A; +} + +export function fn2(optionalEnum: MyEnum | undefined) { + return optionalEnum || MyEnum.B; +} + +export function fn3(optionalEnum?: MyEnum) { + return optionalEnum ?? MyEnum.A; +} + +export function fn4(optionalEnum?: MyEnum) { + return optionalEnum || MyEnum.B; +} + +export function fn5(optionalEnum?: MyStringEnum) { + return optionalEnum || MyStringEnum.B; + } + + +//// [enumMemberReduction.js] +"use strict"; +exports.__esModule = true; +exports.fn5 = exports.fn4 = exports.fn3 = exports.fn2 = exports.fn = void 0; +var MyEnum; +(function (MyEnum) { + MyEnum[MyEnum["A"] = 0] = "A"; + MyEnum[MyEnum["B"] = 1] = "B"; + MyEnum[MyEnum["C"] = 2] = "C"; +})(MyEnum || (MyEnum = {})); +var MyStringEnum; +(function (MyStringEnum) { + MyStringEnum["A"] = "a"; + MyStringEnum["B"] = "b"; + MyStringEnum["C"] = "c"; +})(MyStringEnum || (MyStringEnum = {})); +function fn(optionalEnum) { + return optionalEnum !== null && optionalEnum !== void 0 ? optionalEnum : MyEnum.A; +} +exports.fn = fn; +function fn2(optionalEnum) { + return optionalEnum || MyEnum.B; +} +exports.fn2 = fn2; +function fn3(optionalEnum) { + return optionalEnum !== null && optionalEnum !== void 0 ? optionalEnum : MyEnum.A; +} +exports.fn3 = fn3; +function fn4(optionalEnum) { + return optionalEnum || MyEnum.B; +} +exports.fn4 = fn4; +function fn5(optionalEnum) { + return optionalEnum || MyStringEnum.B; +} +exports.fn5 = fn5; diff --git a/tests/baselines/reference/enumMemberReduction.symbols b/tests/baselines/reference/enumMemberReduction.symbols new file mode 100644 index 0000000000000..f2484d142bd35 --- /dev/null +++ b/tests/baselines/reference/enumMemberReduction.symbols @@ -0,0 +1,87 @@ +=== tests/cases/compiler/enumMemberReduction.ts === +enum MyEnum { +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) + + A, +>A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) + + B, +>B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) + + C, +>C : Symbol(MyEnum.C, Decl(enumMemberReduction.ts, 2, 4)) +} + +enum MyStringEnum { +>MyStringEnum : Symbol(MyStringEnum, Decl(enumMemberReduction.ts, 4, 1)) + + A = "a", +>A : Symbol(MyStringEnum.A, Decl(enumMemberReduction.ts, 6, 19)) + + B = "b", +>B : Symbol(MyStringEnum.B, Decl(enumMemberReduction.ts, 7, 10)) + + C = "c", +>C : Symbol(MyStringEnum.C, Decl(enumMemberReduction.ts, 8, 10)) +} + +export function fn(optionalEnum: MyEnum | undefined) { +>fn : Symbol(fn, Decl(enumMemberReduction.ts, 10, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 12, 19)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) + + return optionalEnum ?? MyEnum.A; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 12, 19)) +>MyEnum.A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) +>A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) +} + +export function fn2(optionalEnum: MyEnum | undefined) { +>fn2 : Symbol(fn2, Decl(enumMemberReduction.ts, 14, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 16, 20)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) + + return optionalEnum || MyEnum.B; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 16, 20)) +>MyEnum.B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) +>B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) +} + +export function fn3(optionalEnum?: MyEnum) { +>fn3 : Symbol(fn3, Decl(enumMemberReduction.ts, 18, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 20, 20)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) + + return optionalEnum ?? MyEnum.A; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 20, 20)) +>MyEnum.A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) +>A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) +} + +export function fn4(optionalEnum?: MyEnum) { +>fn4 : Symbol(fn4, Decl(enumMemberReduction.ts, 22, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 24, 20)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) + + return optionalEnum || MyEnum.B; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 24, 20)) +>MyEnum.B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) +>MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) +>B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) +} + +export function fn5(optionalEnum?: MyStringEnum) { +>fn5 : Symbol(fn5, Decl(enumMemberReduction.ts, 26, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 28, 20)) +>MyStringEnum : Symbol(MyStringEnum, Decl(enumMemberReduction.ts, 4, 1)) + + return optionalEnum || MyStringEnum.B; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 28, 20)) +>MyStringEnum.B : Symbol(MyStringEnum.B, Decl(enumMemberReduction.ts, 7, 10)) +>MyStringEnum : Symbol(MyStringEnum, Decl(enumMemberReduction.ts, 4, 1)) +>B : Symbol(MyStringEnum.B, Decl(enumMemberReduction.ts, 7, 10)) + } + diff --git a/tests/baselines/reference/enumMemberReduction.types b/tests/baselines/reference/enumMemberReduction.types new file mode 100644 index 0000000000000..615b970d2ac84 --- /dev/null +++ b/tests/baselines/reference/enumMemberReduction.types @@ -0,0 +1,90 @@ +=== tests/cases/compiler/enumMemberReduction.ts === +enum MyEnum { +>MyEnum : MyEnum + + A, +>A : MyEnum.A + + B, +>B : MyEnum.B + + C, +>C : MyEnum.C +} + +enum MyStringEnum { +>MyStringEnum : MyStringEnum + + A = "a", +>A : MyStringEnum.A +>"a" : "a" + + B = "b", +>B : MyStringEnum.B +>"b" : "b" + + C = "c", +>C : MyStringEnum.C +>"c" : "c" +} + +export function fn(optionalEnum: MyEnum | undefined) { +>fn : (optionalEnum: MyEnum | undefined) => MyEnum +>optionalEnum : MyEnum + + return optionalEnum ?? MyEnum.A; +>optionalEnum ?? MyEnum.A : MyEnum +>optionalEnum : MyEnum +>MyEnum.A : MyEnum.A +>MyEnum : typeof MyEnum +>A : MyEnum.A +} + +export function fn2(optionalEnum: MyEnum | undefined) { +>fn2 : (optionalEnum: MyEnum | undefined) => MyEnum.B | MyEnum.C +>optionalEnum : MyEnum + + return optionalEnum || MyEnum.B; +>optionalEnum || MyEnum.B : MyEnum.B | MyEnum.C +>optionalEnum : MyEnum +>MyEnum.B : MyEnum.B +>MyEnum : typeof MyEnum +>B : MyEnum.B +} + +export function fn3(optionalEnum?: MyEnum) { +>fn3 : (optionalEnum?: MyEnum) => MyEnum +>optionalEnum : MyEnum + + return optionalEnum ?? MyEnum.A; +>optionalEnum ?? MyEnum.A : MyEnum +>optionalEnum : MyEnum +>MyEnum.A : MyEnum.A +>MyEnum : typeof MyEnum +>A : MyEnum.A +} + +export function fn4(optionalEnum?: MyEnum) { +>fn4 : (optionalEnum?: MyEnum) => MyEnum.B | MyEnum.C +>optionalEnum : MyEnum + + return optionalEnum || MyEnum.B; +>optionalEnum || MyEnum.B : MyEnum.B | MyEnum.C +>optionalEnum : MyEnum +>MyEnum.B : MyEnum.B +>MyEnum : typeof MyEnum +>B : MyEnum.B +} + +export function fn5(optionalEnum?: MyStringEnum) { +>fn5 : (optionalEnum?: MyStringEnum) => MyStringEnum +>optionalEnum : MyStringEnum + + return optionalEnum || MyStringEnum.B; +>optionalEnum || MyStringEnum.B : MyStringEnum +>optionalEnum : MyStringEnum +>MyStringEnum.B : MyStringEnum.B +>MyStringEnum : typeof MyStringEnum +>B : MyStringEnum.B + } + diff --git a/tests/cases/compiler/enumMemberReduction.ts b/tests/cases/compiler/enumMemberReduction.ts new file mode 100644 index 0000000000000..b44ea14037769 --- /dev/null +++ b/tests/cases/compiler/enumMemberReduction.ts @@ -0,0 +1,32 @@ +enum MyEnum { + A, + B, + C, +} + +enum MyStringEnum { + A = "a", + B = "b", + C = "c", +} + +export function fn(optionalEnum: MyEnum | undefined) { + return optionalEnum ?? MyEnum.A; +} + +export function fn2(optionalEnum: MyEnum | undefined) { + return optionalEnum || MyEnum.B; +} + +export function fn3(optionalEnum?: MyEnum) { + return optionalEnum ?? MyEnum.A; +} + +export function fn4(optionalEnum?: MyEnum) { + return optionalEnum || MyEnum.B; +} + +export function fn5(optionalEnum?: MyStringEnum) { + return optionalEnum || MyStringEnum.B; + } + \ No newline at end of file From 5126ba99408d7e4f99bade21b06aecdf5371ea2e Mon Sep 17 00:00:00 2001 From: Lawrence Craft Date: Thu, 16 Jun 2022 10:39:28 +0100 Subject: [PATCH 2/3] format Signed-off-by: Lawrence Craft --- tests/cases/compiler/enumMemberReduction.ts | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/cases/compiler/enumMemberReduction.ts b/tests/cases/compiler/enumMemberReduction.ts index b44ea14037769..41d765cb28d6e 100644 --- a/tests/cases/compiler/enumMemberReduction.ts +++ b/tests/cases/compiler/enumMemberReduction.ts @@ -27,6 +27,5 @@ export function fn4(optionalEnum?: MyEnum) { } export function fn5(optionalEnum?: MyStringEnum) { - return optionalEnum || MyStringEnum.B; - } - \ No newline at end of file + return optionalEnum || MyStringEnum.B; +} From 19c703b1c83d1240e1fb986eac2e2c54c8ceaf7e Mon Sep 17 00:00:00 2001 From: Lawrence Craft Date: Thu, 16 Jun 2022 10:46:05 +0100 Subject: [PATCH 3/3] Adding new test for empty string enum Signed-off-by: Lawrence Craft --- .../reference/enumMemberReduction.js | 28 +++++++-- .../reference/enumMemberReduction.symbols | 61 +++++++++++++------ .../reference/enumMemberReduction.types | 34 ++++++++++- tests/cases/compiler/enumMemberReduction.ts | 10 +++ 4 files changed, 108 insertions(+), 25 deletions(-) diff --git a/tests/baselines/reference/enumMemberReduction.js b/tests/baselines/reference/enumMemberReduction.js index d2a2afcbbc0af..9687432d1fe1b 100644 --- a/tests/baselines/reference/enumMemberReduction.js +++ b/tests/baselines/reference/enumMemberReduction.js @@ -11,6 +11,12 @@ enum MyStringEnum { C = "c", } +enum MyStringEnumWithEmpty { + A = "", + B = "b", + C = "c", +} + export function fn(optionalEnum: MyEnum | undefined) { return optionalEnum ?? MyEnum.A; } @@ -28,14 +34,18 @@ export function fn4(optionalEnum?: MyEnum) { } export function fn5(optionalEnum?: MyStringEnum) { - return optionalEnum || MyStringEnum.B; - } - + return optionalEnum || MyStringEnum.B; +} + +export function fn6(optionalEnum?: MyStringEnumWithEmpty) { + return optionalEnum || MyStringEnumWithEmpty.B; +} + //// [enumMemberReduction.js] "use strict"; exports.__esModule = true; -exports.fn5 = exports.fn4 = exports.fn3 = exports.fn2 = exports.fn = void 0; +exports.fn6 = exports.fn5 = exports.fn4 = exports.fn3 = exports.fn2 = exports.fn = void 0; var MyEnum; (function (MyEnum) { MyEnum[MyEnum["A"] = 0] = "A"; @@ -48,6 +58,12 @@ var MyStringEnum; MyStringEnum["B"] = "b"; MyStringEnum["C"] = "c"; })(MyStringEnum || (MyStringEnum = {})); +var MyStringEnumWithEmpty; +(function (MyStringEnumWithEmpty) { + MyStringEnumWithEmpty["A"] = ""; + MyStringEnumWithEmpty["B"] = "b"; + MyStringEnumWithEmpty["C"] = "c"; +})(MyStringEnumWithEmpty || (MyStringEnumWithEmpty = {})); function fn(optionalEnum) { return optionalEnum !== null && optionalEnum !== void 0 ? optionalEnum : MyEnum.A; } @@ -68,3 +84,7 @@ function fn5(optionalEnum) { return optionalEnum || MyStringEnum.B; } exports.fn5 = fn5; +function fn6(optionalEnum) { + return optionalEnum || MyStringEnumWithEmpty.B; +} +exports.fn6 = fn6; diff --git a/tests/baselines/reference/enumMemberReduction.symbols b/tests/baselines/reference/enumMemberReduction.symbols index f2484d142bd35..7a0939287ae46 100644 --- a/tests/baselines/reference/enumMemberReduction.symbols +++ b/tests/baselines/reference/enumMemberReduction.symbols @@ -25,63 +25,88 @@ enum MyStringEnum { >C : Symbol(MyStringEnum.C, Decl(enumMemberReduction.ts, 8, 10)) } +enum MyStringEnumWithEmpty { +>MyStringEnumWithEmpty : Symbol(MyStringEnumWithEmpty, Decl(enumMemberReduction.ts, 10, 1)) + + A = "", +>A : Symbol(MyStringEnumWithEmpty.A, Decl(enumMemberReduction.ts, 12, 28)) + + B = "b", +>B : Symbol(MyStringEnumWithEmpty.B, Decl(enumMemberReduction.ts, 13, 9)) + + C = "c", +>C : Symbol(MyStringEnumWithEmpty.C, Decl(enumMemberReduction.ts, 14, 10)) +} + export function fn(optionalEnum: MyEnum | undefined) { ->fn : Symbol(fn, Decl(enumMemberReduction.ts, 10, 1)) ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 12, 19)) +>fn : Symbol(fn, Decl(enumMemberReduction.ts, 16, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 18, 19)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) return optionalEnum ?? MyEnum.A; ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 12, 19)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 18, 19)) >MyEnum.A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) >A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) } export function fn2(optionalEnum: MyEnum | undefined) { ->fn2 : Symbol(fn2, Decl(enumMemberReduction.ts, 14, 1)) ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 16, 20)) +>fn2 : Symbol(fn2, Decl(enumMemberReduction.ts, 20, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 22, 20)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) return optionalEnum || MyEnum.B; ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 16, 20)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 22, 20)) >MyEnum.B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) >B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) } export function fn3(optionalEnum?: MyEnum) { ->fn3 : Symbol(fn3, Decl(enumMemberReduction.ts, 18, 1)) ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 20, 20)) +>fn3 : Symbol(fn3, Decl(enumMemberReduction.ts, 24, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 26, 20)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) return optionalEnum ?? MyEnum.A; ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 20, 20)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 26, 20)) >MyEnum.A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) >A : Symbol(MyEnum.A, Decl(enumMemberReduction.ts, 0, 13)) } export function fn4(optionalEnum?: MyEnum) { ->fn4 : Symbol(fn4, Decl(enumMemberReduction.ts, 22, 1)) ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 24, 20)) +>fn4 : Symbol(fn4, Decl(enumMemberReduction.ts, 28, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 30, 20)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) return optionalEnum || MyEnum.B; ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 24, 20)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 30, 20)) >MyEnum.B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) >MyEnum : Symbol(MyEnum, Decl(enumMemberReduction.ts, 0, 0)) >B : Symbol(MyEnum.B, Decl(enumMemberReduction.ts, 1, 4)) } export function fn5(optionalEnum?: MyStringEnum) { ->fn5 : Symbol(fn5, Decl(enumMemberReduction.ts, 26, 1)) ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 28, 20)) +>fn5 : Symbol(fn5, Decl(enumMemberReduction.ts, 32, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 34, 20)) >MyStringEnum : Symbol(MyStringEnum, Decl(enumMemberReduction.ts, 4, 1)) - return optionalEnum || MyStringEnum.B; ->optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 28, 20)) + return optionalEnum || MyStringEnum.B; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 34, 20)) >MyStringEnum.B : Symbol(MyStringEnum.B, Decl(enumMemberReduction.ts, 7, 10)) >MyStringEnum : Symbol(MyStringEnum, Decl(enumMemberReduction.ts, 4, 1)) >B : Symbol(MyStringEnum.B, Decl(enumMemberReduction.ts, 7, 10)) - } - +} + +export function fn6(optionalEnum?: MyStringEnumWithEmpty) { +>fn6 : Symbol(fn6, Decl(enumMemberReduction.ts, 36, 1)) +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 38, 20)) +>MyStringEnumWithEmpty : Symbol(MyStringEnumWithEmpty, Decl(enumMemberReduction.ts, 10, 1)) + + return optionalEnum || MyStringEnumWithEmpty.B; +>optionalEnum : Symbol(optionalEnum, Decl(enumMemberReduction.ts, 38, 20)) +>MyStringEnumWithEmpty.B : Symbol(MyStringEnumWithEmpty.B, Decl(enumMemberReduction.ts, 13, 9)) +>MyStringEnumWithEmpty : Symbol(MyStringEnumWithEmpty, Decl(enumMemberReduction.ts, 10, 1)) +>B : Symbol(MyStringEnumWithEmpty.B, Decl(enumMemberReduction.ts, 13, 9)) +} + diff --git a/tests/baselines/reference/enumMemberReduction.types b/tests/baselines/reference/enumMemberReduction.types index 615b970d2ac84..6eb1530601e18 100644 --- a/tests/baselines/reference/enumMemberReduction.types +++ b/tests/baselines/reference/enumMemberReduction.types @@ -28,6 +28,22 @@ enum MyStringEnum { >"c" : "c" } +enum MyStringEnumWithEmpty { +>MyStringEnumWithEmpty : MyStringEnumWithEmpty + + A = "", +>A : MyStringEnumWithEmpty.A +>"" : "" + + B = "b", +>B : MyStringEnumWithEmpty.B +>"b" : "b" + + C = "c", +>C : MyStringEnumWithEmpty.C +>"c" : "c" +} + export function fn(optionalEnum: MyEnum | undefined) { >fn : (optionalEnum: MyEnum | undefined) => MyEnum >optionalEnum : MyEnum @@ -80,11 +96,23 @@ export function fn5(optionalEnum?: MyStringEnum) { >fn5 : (optionalEnum?: MyStringEnum) => MyStringEnum >optionalEnum : MyStringEnum - return optionalEnum || MyStringEnum.B; + return optionalEnum || MyStringEnum.B; >optionalEnum || MyStringEnum.B : MyStringEnum >optionalEnum : MyStringEnum >MyStringEnum.B : MyStringEnum.B >MyStringEnum : typeof MyStringEnum >B : MyStringEnum.B - } - +} + +export function fn6(optionalEnum?: MyStringEnumWithEmpty) { +>fn6 : (optionalEnum?: MyStringEnumWithEmpty) => MyStringEnumWithEmpty.B | MyStringEnumWithEmpty.C +>optionalEnum : MyStringEnumWithEmpty + + return optionalEnum || MyStringEnumWithEmpty.B; +>optionalEnum || MyStringEnumWithEmpty.B : MyStringEnumWithEmpty.B | MyStringEnumWithEmpty.C +>optionalEnum : MyStringEnumWithEmpty +>MyStringEnumWithEmpty.B : MyStringEnumWithEmpty.B +>MyStringEnumWithEmpty : typeof MyStringEnumWithEmpty +>B : MyStringEnumWithEmpty.B +} + diff --git a/tests/cases/compiler/enumMemberReduction.ts b/tests/cases/compiler/enumMemberReduction.ts index 41d765cb28d6e..adcb42cf628e8 100644 --- a/tests/cases/compiler/enumMemberReduction.ts +++ b/tests/cases/compiler/enumMemberReduction.ts @@ -10,6 +10,12 @@ enum MyStringEnum { C = "c", } +enum MyStringEnumWithEmpty { + A = "", + B = "b", + C = "c", +} + export function fn(optionalEnum: MyEnum | undefined) { return optionalEnum ?? MyEnum.A; } @@ -29,3 +35,7 @@ export function fn4(optionalEnum?: MyEnum) { export function fn5(optionalEnum?: MyStringEnum) { return optionalEnum || MyStringEnum.B; } + +export function fn6(optionalEnum?: MyStringEnumWithEmpty) { + return optionalEnum || MyStringEnumWithEmpty.B; +}