Type predicate for an optional property is not inferred

[amakhrov]

🔎 Search Terms

inferred type predicate optional

🕗 Version & Regression Information

• This changed between versions 5.4 and 5.5

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.5.4#code/C4TwDgpgBA8gRgKygXigbwPZmASwwOwEMAbAfgC51DL8BXAWzggCcBfVgKFElkQCYU6LLgIkKUWvgAmEAGY58EKaygAfIdjxFilNNSh1GLdh1OzJAYxH4oOAM4xNo4gBE5CpQAoIleAgCU6BwA9MFQ4RFQAHqkHJHMEMC0zDYQAHTCWiRQAITIqJIy8opSHJwc5vhWWrYOTtpuxUp83r78gWghYTFxEQlJKVDpmc65+RLS7iVlHEA

💻 Code

type Obj = {optional?: {a: number}}

function isOptionalDefined(e: Obj) {
    return e.optional !== undefined
}

if (isOptionalDefined(someObj) {
  someObj.optional.a // 'someObj.optional' is possibly 'undefined'
}

🙁 Actual behavior

If a type contains an optional property, and I write a function that ensures the property is defined, the function is not inferred as a type predicate. No type narrowing happens when I use this function.

At the same time, if I rewrite the original type to be itself a union, then the type predicate is inferred, as expected.

🙂 Expected behavior

Type predicate is inferred

Additional information about the issue

I feel it has something to do with #55257, but I'm not sure.

[Andarist]

This isn't specific to optional properties:

type Obj = { prop: string | number };

function hasNumberProp(e: Obj) {
  //     ^? function hasNumberProp(e: Obj): boolean
  return typeof e.prop === "number";

See #59088 (comment)

[amakhrov]

Indeed, not specific to optional.
Anyway, having an inline if check would practically (from the usage standpoint) narrow it down - meaning I can access e.optional without a TS error:

if (e.optional) {
  e.optional.a // OK!
}

[Andarist]

The gained knowledge is only about properties, it doesn't propagate to the containing object type:

type Obj = { optional?: { a: number } };

function takeRequired(e: { optional: { a: number } }) {}

function test(e: Obj) {
  if (e.optional) {
    e.optional.a; // OK!
    takeRequired(e); // not OK!
  }
}

That's a current design limitation that is not exclusive to type predicates.

[miguel-leon]

If this worked, it would be really useful for String.matchAll result (RegExpExecArray) with regexp with capturing groups.
Please let us know if the feature is not intended to be this capable.
I understand it's not possible because design limitation, right?

[yukimotochern]

Would be great if this works.

[the-1aw]

I Think you could use something like this to make it work.

/**
 * Create a new type from `T` where property `K` is non-optional.
 */
export type WithRequired<T, K extends keyof T> = T & {
  [P in K]-?: T[P];
};

/**
 * Type guard to signal typescript `obj` contains `name` property.
 *
 * @param obj Any object
 * @param name Any key from obj
 * @returns boolean
 */
export function isWithRequired<T extends object, U extends keyof T>(
  obj: T,
  name: U,
): obj is WithRequired<T, U> {
  return name in obj;
}

type Obj = { optional?: { a: number } };

function takeRequired(e: { optional: { a: number } }) {}

function test(e: Obj) {
  if (isWithRequired(e, "optional")) {
    e.optional.a; // OK!
    takeRequired(e); // OK!
  }
}