Optional chaining, proper infer in type guard

TypeScript Version: 3.7.0

Search Terms: optional chaining

Code

type X = {
  y?: {
    z?: string
  }
}
const x: X = {
  y: {
  }
}
// type guard
function isNotNull<A>(x: A): x is NonNullable<A> {
  return x!== null && x!== undefined;
}
// function which I want to call in the result of the expression
function title(str: string) {
  return str.length > 0 ? 'Dear ' + str : 'Dear nobody';
}

isNotNull(x?.y?.z) ? title(x.y.z) : null // type error - object is possibly undefined

The code fix is by adding additional checks or additional temporary variables:

(x?.y?.z && isNotNull(x.y.z)) ? title(x.y.z) : null
// or
const tmp = x?.y?.z
isNotNull(tmp) ? title(tmp) : null

Expected behavior: TypeScript is able to infer that optional chaining was used as an argument, what means that typeguard is checking the whole chain.

Actual behavior: TypeScript needs a code change in order to understand that optional chaining already checked other values from being null | undefined.

[RyanCavanaugh]

This might be more tractable to fix now that NonNullable has a simpler definition

[RyanCavanaugh]

This is a little tricky; TS sees the x is NonNullable<A> as an opaque treatment of the type of A. As humans we know that if x?.y?.z isn’t undefined/null, then x.y can’t be undefined/null, but TS doesn’t have a way to apply that knowledge through the x is NonNullable<A> check because x is NonNullable<A> is just some generic type that happens to produce some value, not a special check that changes the types of the subexpressions that produced its type argument.