Suggestion: Better typing for key in "for in" loop.

[mpawelski]

I noticed that in generic functions when we use for in loop on object of type T then iterator element is of type keyof T

function testForIn<T>(obj: T) {    
    for (let key in obj) {
        obj[key]; //key: keyof T
    }    
}

But for normal code on not generic object types we always get string as type of key variable:

let example: Example = { propNumber: 1, propString: "foo" };
for (let key in example) {
    let value = example[key];
}

And in this example we'll get any as type of value and error when we'll use noImplicitAny

Suggestion:

Can't we infer the type of key as keyof typeof example which is "propString" | "propNumber". It looks more consistent with generics behavior.

Of couse right now we can do workaround like this:

let example: Example = { propNumber: 1, propString: "foo" };
for (let key in example) {
    let k = key as keyof typeof example;
    let value = example[k];
}

But is it necessary? If key was properly inferred then we would have better typing (no any type when indexing) with no unnecessary additional type annotation.

[mhegazy]

The behavior is intentional, same reasoning as #13989

[mpawelski]

Ok, this reasoning make sense.
But if we had something like exact types from flow (#12936) it would be valid feature to have, right?

[mhegazy]

yes.

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.