Intersection fails if more specific type comes last, again

[muntyan]

This is kind of a dup of #2074, except it's not. That issue says that in the code below FooBar type would behave as Foo, however it produces an error. The reason for the error is not clear since the value satisfies both types.

type Foo = {
type: string,
};

type Bar = {
type: 'specific',
};

type FooBar = Foo & Bar;

({type: 'specific'} : FooBar); // error

[vkurchatkin]

If you think about it, this should be an error. Let's say it's not and you write:

const a: FooBar = { type: 'specific' };

By definition, if a has type A & B it has type A and type B, so the following should be correct:

const b: Foo = a;
const c: Bar = a;

If b has type Foo, then you can do b.type = 'foo', but c points and the same object, so its type becomes incorrect. Hence, {type: 'specific'} is not of type Foo & Bar.

[muntyan]

To me this argument only says that "the following should be correct" is in fact incorrect. It seems to be similar to why you can't do ' list apples; list& fruits = apples; ' in C++.
Also, the same argument applies to Bar & Foo, however according to the explanation in the original issue an object of type Bar&Foo is not necessarily of type Bar, since Bar&Foo behaves simply as Foo.

[vkurchatkin]

This is by definition of intersection. If invariant A <: A & B does not hold, it's not intersection

[muntyan]

Which definition? Mathematical one implies that intersection is symmetrical, but it's not symmetrical in flow (see the original issue). Also, here's a simple example that shows that the above argument about b changing type is invalid, object does in fact change its type (or rather the set of types it has) when it's modified:

type X = { x: string };
type Xa = {x:'a'};
type Xb = {x:'b'};
x = {x:'a'};
(x:Xa); // no error
x.x = 'b';
(x:Xa); // error, x is no longer Xa

[vkurchatkin]

In your example there are no contradicting references to the same object, hence no unsoundness. Otherwise it would be a bug