Optional chaining, proper infer in type guard

[maciejsikora]

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 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.

[MartinEneqvistRegionSkane]

I have a similar issue with type guards.

This compiles:

type Person = { name: string; }

const getName = (person?: Person): string => {
  return typeof person?.name === 'string' ? person?.name : '';
};

But this does not:

type Person = { name: string; }

const isString = (value: any): value is string => {
  return typeof value === 'string';
};

const getName = (person?: Person): string => {
  return isString(person?.name) ? person?.name : '';
};

// Type 'string | undefined' is not assignable to type 'string'.
//   Type 'undefined' is not assignable to type 'string'.

I would have expected these examples to be equivalent.

Is there another way to write the isString type guard function so that this works?

[lo1tuma]

I’ve encountered the same problem.
@ShuiRuTian will this be fixed by #38839 as well?

[ShuiRuTian]

@lo1tuma Sorry, but no.

As Ryan said, type guard is not a part of control flow analytics, so type narrowing is not working.

Here is a compare:

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;
}

if (x?.y?.z != null && x?.y?.z != undefined) {
    x.y.z // this works after 38839
}

if(isNotNull(x?.y?.z)){
    x.y.z // // However, this not
}

[stabai]

TypeScript knows how to do this properly if you directly check that the chained variable is not null/undefined. It only fails if you use a type guard to check it.

This works:

if (animal?.breed?.size != null) {
  return animal.breed.size;
} else {
  return undefined;
}

This doesn't:

if (!isNil(animal?.breed?.size)) {
  return animal.breed.size;   // Error: Object is possibly 'undefined'. (2532)
} else {
  return undefined;
}

function isNil(value: unknown): value is undefined | null {
    return value == null;
}

Here is a playground link demonstrating this.

I don't know what TypeScript is doing internally, but the fact that one works and the other doesn't is what makes this feel like a bug to me rather than a type system limitation.