narrowing in switches doesnt work on constrained unions

[zpdDG4gta8XKpMCd]

assuming my understanding it right: an extended union is a subset (subtype) of the original union

 declare function never(never: never): never;
 type X = 'A' | 'B' | 'C';
 void function fn<Y extends X>(y: Y): Y {
 switch (y) {
 case 'A': return y;
 case 'B': return y;
 case 'C': return y;
 default: return never(y); // <-- y expected to be never, actual Y
 }
 }

same problem with objects

 type X = { k: 'A' } | { k: 'B' } | { k: 'C' };
 void function fn<Y extends X>(y: Y): Y {
 switch (y.k) {
 case 'A': return y;
 case 'B': return y;
 case 'C': return y;
 default: return never(y); // <-- y expected to be never, actual Y
 }
 }

[masaeedu]

Nvm earlier comment, misunderstood what you meant by "extended". The weird part here is y is being inferred as never in each of the 'A', 'B' and 'C' cases.

[mhegazy]

Generics that are constrained to literal types are not treated like literals at the moment. generics have a more conservative behavior when narrowing in general since the actual type is not known, but generics with literal constraints should be behave like a union of literals.

[sandersn]

In the first example, y is never in the case A/B/C branches. This, too , seems wrong.

declare var n: never;
function fn<Y extends "A" | "B" | "C">(y: Y): Y {
 switch (y) {
 case 'A': n = y; return y; // ok!
 case 'B': n = y; return y;
 case 'C': n = y; return y;
 default: n = y; return never(y); // <-- y expected to be never, actual Y
 }
}

[RyanCavanaugh]

This is indeed super wrong