Update type definition of Object.keys

[kube]

Solves need to explicitly specify type of key when in Strict Mode.

Issue it solves

const someObj = {
  a: 42,
  b: 'Hello'
}

Object.keys(someObj)
  .forEach(key =>
    someObj[key] // ERROR: Element implicitly has an 'any' type because type ... has no index signature.
  )

[msftclas]

This seems like a small (but important) contribution, so no Contribution License Agreement is required at this point. We will now review your pull request.
Thanks,
Microsoft Pull Request Bot

[ikatyang]

These files are not meant to be edited by hand. If you need to make modifications, the respective files should be changed within the repository's top-level src directory. Running jake LKG will then appropriately update the files in this directory. (/lib@master#read-this)

---> /src/lib@master#read-this

And also, there is already a similar PR, see #17261 (only modify the type of o).

[kube]

Ok sorry for not reading, and thanks for your comment. :/

PR #17261 does not solve this issue, as it just restricts what can be passed to Object.keys.

My PR is to link the output type of Object.keys to the input type, and I don't think it's possible without a generic type.

[ikatyang]

EDIT: overload does nothing in this case.

I think it'd be better to add overload instead of modifying the original one, since Object.keys should always return string[], consider the following case:

declare function keys<A>(o: A): (keyof A)[];
declare const x: object;

keys(x); //=> never[]; <------- should be string[]

[jwbay]

See - #15295,
#13254,
#12253 (comment)

[Jessidhia]

<A extends {}>

The problem with making Object.keys return keyof A is that typescript makes no guarantees that the input object has only the keys that are specified in its type. There may be valid values in the array that are not considered by the type.

[rbuckton]

@sandersn, can you take a look?

[sandersn]

I think the issue raised in #12253 (comment) still holds: (keyof T)[] is not useful or accurate when Object.keys is called with an object that has more properties than its declared type. I'll close this PR in favour of the simpler #17261 that just has o: {}.