Type assertion for string literals stopped working

[normalser]

TypeScript Version: 2.1.0-dev.20160912

Code

// A *self-contained* demonstration of the problem follows...
const types = {
    test: <'test'>'test',
    test2: 'test2' as 'test2'
} // type: {test: string, test2:string}

let a = <'test'>'test'  // type string

Probably related to: #10676

[ahejlsberg]

Yes, this is related to #10676. Previously, a string literal would have a literal type only in certain "literal contexts" (such as after a type assertion) and we would just use the exact type of an expression as the inferred type of an object literal property. Now, string literals always have literal types and instead we widen types when they're inferred for mutable locations (such as object literal properties). So, in your example, the type assertions have no effect (a) because the string literals are already of literal types and (b) because we widen the result of the entire expression after the type assertion.

For better backwards compatibility we could consider not widening an inferred type when the initializer expression is a type assertion. After all, what would be the point of the type assertion otherwise?

[normalser]

@ahejlsberg Thank you for the response.

It would be great if you could consider not widening an inferred type when the initializer expression is a type assertion - and agree - that's kind of the point of the type assertion :)

Another common case that will stop working without it is:

function test(style: { align: 'left' | 'right', size: number }) {
}

const style = {
    align: 'left' as 'left',
    size: 5
}

test(style)

Syntax for literal types #10195 would help - but I'm not sure if it will ever become a reality

Thanks a lot for everything

[ahejlsberg]

@wallverb Agreed, it would be nice to have some form of syntax to indicate you don't want widening without having to explicitly state the type. But regardless, for backwards compatibility reasons we should allow type assertions to have that meaning.