Mapped types over keyof T should be subtypes of types with string index signatures

[cwmacdon]

TypeScript Version: 2.2.1

Code

// helpers to map types
type Dictionary = {
    [key: string]: string;
};

interface IBaseEntity {
    name: string;
    properties: Dictionary;
}
interface IEntity<t> extends IBaseEntity {
    properties: Record<t, string>;
}

Expected behaviour:
No Compile error.

Actual behaviour:
Compile error:

Interface 'IEntity<t>' incorrectly extends interface 'IBaseEntity'.
  Types of property 'properties' are incompatible.
    Type 'Record<t, string>' is not assignable to type 'Dictionary'.

Edit: Replace StrictDictionary with Record<t, string>. Show full compile error.

[mhegazy]

I suppose if the source is a generic mapped type, and the target only has string indexer, then the two types are relatable iff the template type of the source is relatable to the type of the index signature of the target.

[cwmacdon]

So you're saying if we constrain the generic type in StrictDictionary<t> then theoretically it would be reasonable for this to work?

[mhegazy]

I am saying this is a new type compatibility rule we need to encode in the compiler.

[cwmacdon]

It would also be nice if the return type of Object.keys() on a StrictDictionary<t, u> was keyof t.

[krryan]

The problem with that idea, @cwmacdon is that our "StrictDictionary" might actually be something that extends StrictDictionary<t> and so Object.keys() would return strings that are not keyof t. Yet another use-case for nominal typing...

[wclr]

Is it in the nightly build yet?