Strict null checks, index signatures, and optional properties.

[sccolbert]

This may be related to #13778

I want to define a type which restricts the allowable values of properties to a specific set of types. Sub-types may define certain properties to be a more specific subset of the allowable types (think JSON object but with well-formed, known keys).

The code below is a simplified demonstration, but I run into problems with sub-types specifying optional properties when strictNullChecks is turned on. Compilation fails with a message saying the property is incompatible with the index signature. It strikes me as odd that this is not allowed, at the same time the index signature does not have an implicit undefined . If anything, the well typed property is more safe than using the index signature. My intuition is not than an index signature should have an implicit undefined, but that the below code should be allowed with strictNullChecks. I realize that foo?: T is treated the same as foo: T | undefined by the compiler, but there is a distinct difference between the lack of presence of key, and a key with undefined as a value. Usually the distinction doesn't matter, but in this case it does.

TypeScript Version: 2.4.0

Code

interface Thing {
  [key: string]: string | number | boolean;
}

interface Other extends Thing {
  bar: boolean;  // always okay
  foo?: string;  // not okay with strictNullChecks
}

Expected behavior:
Compiles with strictNullChecks

Actual behavior:
Does not compile with strictNullChecks

[jcalz]

I'm sure this is intended behavior.

In the presence of strictNullChecks, the definition of Thing means that it will return a defined value for any string key you use (which I assume would require a Proxy to actually implement). Specifically, it has a defined foo property:

declare let thing: Thing;
thing.foo.toString(); // no possibly-undefined warning 

As you noted, there's not much difference in TypeScript between an optional property and a required property with a possibly-undefined value. If you access an absent property, it will produce an undefined result. So the definition of Other says that accessing the foo property might produce an undefined result, which cannot happen if Other extends Thing.

If you are trying to say that Thing might not have values for every possible key, then you should define it as

interface Thing {
  [key: string]: string | number | boolean | undefined;
}

If your main issue is with the way TypeScript treats missing keys, then maybe you should head over to #13195 and upvote and/or contribute. Cheers!

[sccolbert]

I guess my main argument is the inconsistency. If we're going to say "okay, index signatures may be undefined if you misspell something, but that would be a pain to force it everywhere even with strictNullChecks", then an optional property should also be compatible with the index signature by the exact same line of reasoning.

[mhegazy]

Index signature is a constraint on the type. it is assumed that all properties would fall under this constraint.. otherwise obj[string] would be a lie.

[typescript-bot]

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