TS2322 error in tsgo but not tsc

[jfirebaugh]

Steps to reproduce

With default compiler options:

enum E {
  Foo,
  Bar,
}
type A = { type: 'a'; e: E }
type B = { type: 'b' }
type C = A & { e: E.Bar }

function fn(v: A | B | C): A | B | C {
  return { ...v, e: E.Foo }
}

Behavior with typescript@5.8

Typechecks successfully.

Behavior with tsgo

index.ts:10:18 - error TS2322: Type 'E.Foo' is not assignable to type 'E.Bar'.

[RyanCavanaugh]

This is from microsoft/typescript-go#1085 which was ported to 5.9 in #61828

Notably the intersection is not required

enum E {
  Foo,
  Bar,
}
type A = { type: 'a'; e: E }
type B = { type: 'b' }
type AA = { type: 'a'; e: E.Bar }

function fn(v: A | B | AA): A | B | AA {
  // Error in 5.9 but not 5.8
  return { ...v, e: E.Foo }
}

[ahejlsberg]

Yup, this is working as intended.

[ahejlsberg]

I was a little quick to say it's working as intended. Ideally, we should report an excess property error here, not a type mismatch error.

The type of the object literal expression in Ryan's example is { type: "a", e: E.Foo } | { type: "b", e: E.Foo }. Assignment of that type to A | B | AA results in detecting an excess property e when relating { type: "b", e: E.Foo } to B (as per microsoft/typescript-go#1085). But then our error elaboration logic (which is tasked with reporting an error on a specific property instead of the containing type) gets tripped up by the similarity of A and AA and ends up relating E.Bar to E.Foo.

The core issue here is that the error elaboration logic can't properly discriminate a target type when the source type is a union, and it ends up falling back on the "most overlappy type"--which here is a toss-up between A and AA and ends up depending on type ordering.

The order dependency can be observed with 5.9 by moving the declaration of AA before A:

enum E {
  Foo,
  Bar,
}

type AA = { type: 'a'; e: E.Bar }
type A = { type: 'a'; e: E }
type B = { type: 'b' }

function fn(v: A | B | AA): A | B | AA {
  return { ...v, e: E.Foo }  // Excess property error as expected
}

Similarly, it can be observed in tsgo by renaming A to AAA (which sorts after AA).

This isn't a major defect, but probably something we want to fix at some point.