When an index signature is not available, encourage using a more specific type to index the type.

[threehams]

Search Terms

index signature, keyof, domain: error messages
Vaguely related:
#14951

Suggestion

When there is a type error because of a missing string index signature, add a suggestion of:
"Did you mean to use a more specific type such as keyof Thing instead of string?"

Only show this message:

• if the type used to index is within the same scope
• the object being indexed is not empty

Use Cases

Take the following example:

interface Person {
  name: string;
  phone: string;
}
declare const person: Person;

const get = (person: Person, key: string) => {
  return person[key];
};

get(person, "name");

The error message here is:

Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'Person'.
  No index signature with a parameter of type 'string' was found on type 'Person'.

This is technically correct! However, many people read this error message to mean "add an index signature to Person," rather than advising them to use a more specific type than string, like keyof Person. Adding the index signature suppresses the error, making it seem like the correct solution.

Where this doesn't work

There are some cases where this advice would not make sense:

// Did you mean to use a more specific type such as `keyof Number` instead of `string`?
1["a" as string]

Other cases I can think of so far:

• Empty objects, especially from reduce (suppress for empty objects)
• Indexing an object by number (only do this for strings?)
• Object.keys and Object.entries as discussed many, many times (require the indexing type to be in the same scope)

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[allandiego]

As a new Typescript user i got confused with this error message, just realized how to solve the error after reading this issue part "keyof Type", then everything made sense, upvote to improve message description

[grant]

In my case, using as keyof MyInterface was the solution:

const unknownKey = myString as keyof MyInterface;
myObject[unknownKey] = ...;

[j0053f]

why can't I narrow it with the "in" operator?
e.g.

function get(person: Person, key: string) {
     if (key in person){
        return person[key];
    }
};