Type guard should infer the type of parent object when applied on a property

[KurtGokhan]

Suggestion

🔍 Search Terms

Type guard, parent object, infer, inference

✅ Viability 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, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Typescript should be able to infer the type of an object, if a type guard was checked on a property of the said object. Currently, Typescript does correctly infer the type of the property, but not its parent object.

📃 Motivating Example

The following example is very common in data oriented design.

interface Type1 { list: string[] }

interface Type2 { list: { [key: string]: string } }

declare const obj: Type1 | Type2;

if(Array.isArray(obj.list)) {
    const list: string[] = obj.list; // WORKS
    const map: { [key: string]: string } = obj.list; // ERROR, as expected
    const objCasted: Type1 = obj; // ERROR, unexpectedly
} else {
    const map: { [key: string]: string } = obj.list; // WORKS
    const list: string[] = obj.list; // ERROR, as expected
    const objCasted: Type2 = obj; // ERROR, unexpectedly
}

The following example works and that is good because it is an equally common case in this type of design.

interface Type3 { type: 'type3', data: boolean }

interface Type4 { type: 'type4', data: string }

declare const obj2: Type3 | Type4;

if(obj2.type === 'type3') {
    const objCasted: Type3 = obj2; // WORKS
} else {
    const objCasted: Type4 = obj2; // WORKS
}

So I believe the type guards should work the same way. As far as I see, this does not cause any inconsistency in the language or the type system. It is an improvement without any downsides.

💻 Use Cases

See the full example.

[MartinJohns]

Quoting @jack-williams:

Type guards do not propagate type narrowings to parent objects. The narrowing is only applied upon access of the narrowed property which is why the destructing function works, but the reference function does not. Narrowing the parent would involve synthesizing new types which would be expensive. More detail in this comment.

Used search terms: type guard property parent

[KurtGokhan]

@MartinJohns Thanks but I am trying to understand why. Consider this example:

interface Type5 { type: boolean }

interface Type6 { type: string }

declare const obj3: Type5 | Type6;

if(typeof obj3.type === 'boolean') {
    const objCasted: Type5 = obj3; // ERROR, unexpectedly
} else {
    const objCasted: Type6 = obj3; // ERROR, unexpectedly
}

if(obj3.type === true) {
    const objCasted: Type5 = obj3; // WORKS
} else if(obj3.type === '') {
    const objCasted: Type6 = obj3; // WORKS
}

So if I check with obj3.type === true, it narrows the type of the parent correctly. So the type property is correctly detected as a discriminator property. But type guards don't narrow the the of the parent and that is by choice. Is that because of performance concerns? Type guard seems like a more exhaustive mechanism than simple equality check. I would expect it to be easier to implement.

[RyanCavanaugh]

I want to take another look at this; seems like we might have the right machinery in place now

[JoshuaWise]

I ran into this issue today, and would love to see it resolved. In my case, I'm using the excellent SuperStruct package to validate parts of an incoming HTTP request in Koa. I'm using the type guards generated by SuperStruct to validate the query parameters (ctx.query) and request body (ctx.request.body). However, the parent ctx object is not affected by these type guards, so I can't pass the ctx to a type-safe handler (e.g., a handler that expects the ctx.request.body to match a certain schema).

[bartenra]

I ran into a similar situation today, which boiled down to (see duplicated issue):

type Slot = { id?: string }

function needsId(slot: { id: string }) {
}

function test(slot: Slot) {
  if (slot.id) {
    needsId(slot)
  }
}