Narrowing via property check fails when adding parent type to declaration

TypeScript Version: 3.8.3

Search Terms:

• property check refinement

Expected behavior: No error, type is narrowed to SubA.

Actual behavior: Type is narrowed to never and produces an error.

Related Issues:

• https://github.com/microsoft/TypeScript/issues/1260

Code

This code type checks:

interface Base {
  base: number;
}

interface SubA extends Base {
  a: string;
  other: boolean;
}
interface SubB extends Base {
  b: string;
}

function foo(x: SubA | SubB | null) {
  x = x || {base: 1, b: 'b'};
  if (x && 'a' in x && x.a == 'str') {
    x.other;  // ok
  }
}

A very tiny tweak (adding Base | to the parameter type) breaks things, though:

function foo(x: Base | SubA | SubB | null) {
  x = x || {base: 1, b: 'b'};
  if (x && 'a' in x && x.a == 'str') {  // <-- Property 'a' does not exist on type 'never'. (2339)
    x.other;  // <-- Property 'other' does not exist on type 'never'. (2339)
  }
}

This makes some sense since foo could be called with something assignable to Base that has an a but is not specifically a SubA. But what doesn't make sense to me is that removing the assignment on the first line makes the error go away:

function foo(x: Base | SubA | SubB | null) {
  if (x && 'a' in x && x.a == 'str') {  // ok
    x.other;  // ok
  }
}

That assignment seeming has no bearing on if statement (the default value doesn't have an a property). So why does it affect the inferred type in it?

Either the second and third example should both error or neither of them should.

"use strict";
function foo(x) {
    x = x || {base: 1, b: 'b'};
    if (x && 'a' in x && x.a == 'str') {
        x.other;
    }
}

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "alwaysStrict": true,
    "esModuleInterop": true,
    "declaration": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "moduleResolution": 2,
    "target": "ES2017",
    "jsx": "React",
    "module": "ESNext"
  }
}

Playground Link: Provided

Commencez par la reproduction fournie dans TypeScript Playground et comparez les trois exemples de foo, en vous concentrant sur la manière dont l’affectation modifie le narrowing fondé sur les vérifications de propriétés. L’issue est terminée lorsque le comportement est cohérent entre ces exemples et que les erreurs never signalées sont corrigées ou documentées intentionnellement.