Type casting a variable to its own type should preserve literal widening information

[ethanresnick]

Bug Report

🔎 Search Terms

literal widening typeof

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries

⏯ Playground Link

Playground link with relevant code

💻 Code

const foo = "fooey";  // widening
let id1 = foo; // widening 
let id2 = foo as typeof foo; // non-widening

id1 = "hello" // ok
id2 = "hello" // type error

🙁 Actual behavior

Assigning to id2 gives a type error, while assigning the same thing to id1 does not.

🙂 Expected behavior

There should be absolutely no difference between id1 and id2, because foo as typeof foo should be an identity cast/no-op.

[fatcerberus]

Interestingly enough, this code (adapted from @RyanCavanaugh's "Gordian Knot" snippet here) does work today:

function id<T>(x: T): T { return x; }

const x = id("hello");
fn(x);
let y = x;
y = "world";

declare function fn(x: "hello"): void;

So it seems that TS can sometimes retain the widening hint across a type parameter inference. Which maybe makes it even weirder that foo as typeof foo isn't a no-op.

[RyanCavanaugh]

The code that does this was very much put there on purpose in #25471, which fixed a bug described in #25469. I think somewhat critically, a widening literal type isn't a type you should ever be able to "capture".

We can see what breaks in practice - maybe the use cases are well-handled via other means now. I'll put up a draft PR and we can run the user tests.

[fatcerberus]

I think somewhat critically, a widening literal type isn't a type you should ever be able to "capture".

Nonetheless, it does appear to be captured by my generic id function above (which surprised me because I initially didn't expect it to work).