Index signatures in mapped types override property types

[zamb3zi]

TypeScript Version: nightly (2.2.0-dev.20161204)

Code

type T1 = {a?: number};
let o1: T1 = {a: 'no'}; // error: Type '{ a: string; }' is not assignable to type 'T1'
let p1: Partial<T1> = {a: 'no'}; // same error

type T2 = {a?: number, [key: string]: any};
let o2: T2 = {a: 'no'}; // error: Type '{ a: string; }' is not assignable to type 'T2'
let p2: Partial<T2> = {a: 'no'}; // ok - expected same error
let p3: {[P in keyof T2]: T2[P]} = {a: 'no'}; // also ok - expected same error

Expected behavior:

Applying Partial<T> to a type T that has an index signature should not modify the expected property types. The issue is the same regardless of whether the properties of T are optional or not and for the identity type mapping {[P in keyof T]: T[P]}.

The problem seems to be that the type mapping elevates the index signature to a higher priority in the mapped type than in the original type.

Actual behavior:

Partial<T & {[key: string]: any}> is identical to {[key: string]: any} for all types T, making Partial useless for types that have an index signature.

[mhegazy]

keyof T2 is "a" | string and since string subsumes "a" then you are left with string.

the issue here is index signature on a type is a general constraint on "all" properties on the type. it is not meant to apply to "other properties that are not called a". so your type declaration is too loose originally.

[zamb3zi]

In our case, the original type is the Angular IScope which we do not have the option of tightening.
I feel like this is a real problem that would be solved by allowing type mappings to treat index signatures differently. In particular, it's meaningless for Partial to map index signatures this way.

[mhegazy]

This is not special to index signatures. the indexes from keyof are just types, and they flow in the system the same way all other type do. from a type system perspective, string is a super type of a literal type "a". and in places where the subtype reduction process takes place, the "a" will always be lost.

this is similar to saying something like var x: "a" | string it is still a string, and so is var x: any | string it is an any.