Generic lookup type wrongly narrowed to `never` with strictNullChecks

[mattmccutchen]

I ran across this while migrating my project to strictNullChecks and it's positively bizarre.

TypeScript Version: master (50f442f)

Search Terms: mapped type narrow narrowing null strictNullChecks never

Code (with strictNullChecks)

let mappedObject: {[K in "foo"]: null | {x: string}} = {foo: {x: "hello"}};
declare function foo<T>(x: T): null | T;

function bar<K extends "foo">(key: K) {
  const element = foo(mappedObject[key]);
  if (element == null)
    return;
  const x = element.x;
}

Expected behavior: Compile without error.

Actual behavior: Error: Property 'x' does not exist on type 'never'.

Playground Link: link (remember to enable strictNullChecks)

Related Issues: Didn't find any.

[RyanCavanaugh]

This is just weird. Writing

const x = element!.x;

eliminates the error, but there shouldn't be anything for ! to take away

[RyanCavanaugh]

Not a regression FWIW

[weswigham]

This is just weird. Writing
const x = element!.x;
eliminates the error, but there shouldn't be anything for ! to take away

FWIW !, as a cast, also resets a control flow-narrowed type to its declared type. We have an open issue to make it respect narrowing: #16945 (I was looking at it recently)

[mattmccutchen]

I found the problem: in getAssignmentReducedType, we have a declared type of {x: string} | null and an assigned type of {foo: {x: string} | null}[K] | null. When we ask if the assigned type is maybe assignable to {x: string}, we decompose the first level of union and check if {foo: {x: string} | null}[K] is assignable to {x: string}, but it isn't because its constraint is {x: string} | null. So we throw {x: string} out of the declared type and are left with null, and after the null check, we are left with never.

Using the comparable relation in place of typeMaybeAssignableTo fixes this issue. I'm going to see what else breaks if I do that.

[mattmccutchen]

Proposed fix is in #26143.