Type is cannot satisfy A and cannot satisfy B but satisfies A | B

[jisaacks]

🕗 Version & Regression Information

v4.3.5

⏯ Playground Link

Playground link with relevant code

💻 Code

type A = Partial<{ 
  foo: number
  bar: string
}>

type B = Partial<{
  foo: number
  other: string
}>

type C = A & B & { $inherit: "b" }

const a: A = {
  foo: 3,
  other: 'cool', //'other' does not exist in type
}

const b: C = { // $inherit is missing
  foo: 3,
  other: 'cool',
}

const c: A | C = { // OK ????
  foo: 3,
  other: 'cool',
}

🙁 Actual behavior

c is OK.

🙂 Expected behavior

If the same structure cannot satisfy A and cannot satisfy B it should be logical to assumed that it cannot satisfy A | B but here it does.

I would expect that since I have included other it cannot be A and since I have not included $inherit it cannot be C so I would expect this to fail. I would expect that I could only make const c ok by either removing other: cool or by adding $inherit: "b"

[RyanCavanaugh]

Excess property checking (other in a) is a heuristic that tries to, without false positives, identify properties that "don't belong there". It is not a facet of the type system per se -- excess properties are OK in the subtype relationship. As such, it sometimes will issue fewer errors in the presence of different hints.

What we found in real-world code is that there were many cases where people wrote unions that didn't capture the full extent of allowed properties, so excess property checking allows excess properties as long as a matching property name is found anywhere in the target union.

[jisaacks]

@RyanCavanaugh this seems weird. I mean That is how I would expect Partial<A & C> to work. Not how I would expect A | C to work.

It just seems illogical that by design X != A, X != C, X == A | C

So if this is by design, then is there a way to actually achieve this, so that a type MUST satisfy one of the union types NOT a mishmash of parts of different types in the union?

[RyanCavanaugh]

So if this is by design, then is there a way to actually achieve this, so that a type MUST satisfy one of the union types NOT a mishmash of parts of different types in the union?

const c: A | C = { // OK!
  foo: 3,
  other: 'cool',
}

The initialization here is a valid A; you could equally write

const d = {
  foo: 3,
  other: 'cool',
};
const c: A | C = d;

You might be looking for #12936 or #14094, depending

[jisaacks]

@RyanCavanaugh but that is bypassing the object literal.

I could also do:

const d = {
  foo: 3,
  other: 'cool',
};
const a: A = d;

even though I cannot do:

const a: A = {
  foo: 3,
  other: 'cool', //'other' does not exist in type
}

I was under the impression that extra properties were OK when using a variable but NOT OK when using an object literal.

So it seems like you can bypass the object literal restriction on excess properties as long as the type is a union?

[MartinJohns]

So it seems like you can bypass the object literal restriction on excess properties as long as the type is a union?

See #20863.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.