Refine unions in contextual typing

[RyanCavanaugh]

Source issue #16450 and others (TODO: find them)

This code should work, but doesn't:

interface X {
    type: 'x';
    value: string;
}

interface Y {
    type: 'y';
    value: 'none' | 'done';
}

function foo(bar: X | Y) { }

foo({
    type: 'y',
    value: 'done',
});

Similar example:

interface X {
    type1: 'x';
    value: string;
}

interface Y {
    type2: 'y';
    value: 'none' | 'done';
}

function foo(bar: X | Y) { }

foo({
    type2: 'y',
    value: 'done',
});

We can, in principle, make this work by discarding X from the union.

In the first example, this can be done (somehow) by using the discriminating union from the object literal.

In the second example, this can be done by noting that we have a fresh object literal type (meaning there are known to be no additional properties) and a missing type1 property.

[timwangdev]

+1
Looking forward to see any progress on this!

[jebcat1982]

Microsoft has the current version at typescript.com

[mhegazy]

seems to be the same underlying issue as #18365

[sandersn]

I have a fix for the first example, but note that the first example won't magically work because value looks like a discriminant too, albeit not a useful one. This fails with current narrowing as well:

function f(xy: X | Y) {
  if (xy.value === 'done') {
    // xy: X | Y
  }
  else {
    // xy: X | Y
  }
}

That's because, as a discriminant, string | 'none' | 'done' boils down to just string.