Union type two interfaces (non-primitive unions)

[TrySpace]

I doubt this is expected behaviour, but it might be that I'm missing something.

Code
Doing this:

interface One {
  one: string;
}

interface Two {
  two: string;
}

type Three = One | Two;

const what1: Three = { one: 'ok' };
const what2: Three = { two: 'ok' };

const good1 = what1.one;
const good2 = what2.two;

good1 & good2 are good.

But adding a property to One:

interface One {
  one: string;
  extra: number; // <-- New line
}

interface Two {
  two: string;
}

type Three = One | Two;

const what1: Three = { one: 'ok' }; // Error
const what2: Three = { two: 'ok' };

const good1 = what1.one; // Error
const good2 = what2.two;

Typescript will warn about both what1 and what1.one, respectively:

 TS2322: Type '{ one: string; }' is not assignable to type 'Three'.
  Type '{ one: string; }' is not assignable to type 'Two'.
    Property 'two' is missing in type '{ one: string; }'.

So instead of error for missing extra prop, it will error for it missing a type from a seemingly arbitrary type.

and

TS2339: Property 'one' does not exist on type 'Three'.
  Property 'one' does not exist on type 'Two'.

Here it looks like ts has coerced/figured out the type already.

Playground Link:
Just uncomment the line here

Trying to align them doesn't help:
When I add the extra property to the second type

What fixes these issues is when I change it into an optional extra?: string: here

Expected behavior:
I would have expected it to behave like logical or, but adding new properties seems to break the union.
Invalid, but maybe something like this: type Three = One? | Two?; is what I actually expected?
I expected no error.

Actual behavior:
The union seems to behave as &.

If I do foo: string | number, I expect foo to accept either type.
My guess is that with non-primitive types it doesn't work like that, since I couldn't literally merge an object with a boolean, so it merges the two interfaces, but somehow both are being reverse hypocritical, as in either are complaining about something the other is missing, while they have it themselves. And the order doesn't matter either, so they will always be incompatible whatever you try.
But that doesn't explain why it would work without the extra property, but different properties.

Related Issues:
#23031 The title seems to match my issue, but the errors are different. Although I have to say I've had that error before in relation to using two interfaces in union.

Search Terms:
type interfaces union

[jack-williams]

This seems fine to me (unless I'm missing something). Do you expect there not to be an error, or a different error?

• { one: 'ok' } is not assignable to type One (modified) because it doesn't have the property extra.
• { one: 'ok' } is not assignable to type Two because it doesn't have the property two.

Therefore { one: 'ok' } is not assignable to type One | Two, a.k.a. Three.

If the union behaved as intersection then you'r first example would error too.

[evmar]

When you write

const what1: Three = { one: 'ok' }; // Error

The compiler sees that it doesn't match either One or Two, and from there it can't know which one you were aiming for because neither match. And it's not as simple as just picking the "closer" one, because sometimes there's a lot of different candidates -- you'll frequently see this come up in more complex scenarios where there's a whole chain of aliases and interfaces and the compiler goes down the wrong arm of some intersection.

[TrySpace]

@evmar But why does the 2nd error occur? The property .one exists on type One, yet it errors.

@jack-williams it doesn't actually act as an intersection, it just seems like it, and that only seems to happen when I have an uneven amount of properties?

Main questions/confusions:

Property 'one' does not exist on type 'Three'. - Yes it does, and why didn't you tell me this before the property was added to One?

Type '{ one: string; }' is not assignable to type 'Three'. - False, it does, and it did exist before the new prop.

Type '{ one: string; }' is not assignable to type 'Two'. True, but what happened to One?

Property 'two' is missing in type '{ one: string; }'. - True I guess, but it just assumed a type.

[RyanCavanaugh]

Please use StackOverflow for questions. It is not the case that we've been shipping a buggy implementation of union types for several years.