Type union narrowing in callbacks

[sccolbert]

TypeScript Version: 2.3.1

Code

type Thing = {
  type: 'thing';
  thing: number;
  doStuff(cb: (value: Thing) => void): Thing;
}


type Foo = {
  type: 'foo';
  foo: number;
  doStuff(cb: (value: Foo) => void): Foo;
}


type Bar = {
  type: 'bar';
  bar: number;
  doStuff(cb: (value: Bar) => void): Bar;
}


type Baz = {
  type: 'baz';
  baz: number;
  doStuff(cb: (value: Baz) => void): Baz;
}


type Stuff = Thing | Foo | Bar | Baz;


function main() {
  let stuff: Stuff;
  if (stuff.type !== 'thing' && stuff.type !== 'foo') {
    return;
  }
  stuff = stuff.doStuff((value: Foo | Thing) => {
    value; // value should be Foo | Thing here, but fails with error TS2349: Cannot invoke an expression whose type lacks a call signature....
  });
}

Expected behavior:

It seems like the above snippet should compile.

Actual behavior:

The compiler doesn't see the callback as compatible with the callback required by the remaining types in the union.

[yortus]

Same cause as #1805?

[mhegazy]

Duplicate of #7294

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.