Processing of Callables in make_simplified_union is order dependent

[ddfisher]

from typing import Union, Any

class A():
    def foo(self, x: Any) -> None: pass

class B():
    def foo(self, x: str) -> None: pass

def f(c: Union[A, B]) -> None:
    reveal_type(c.foo)  # E: Revealed type is 'def (x: Any)'

def g(c: Union[B, A]) -> None:
    reveal_type(c.foo)  # E: Revealed type is 'def (x: builtins.str)'

Prior to #1989 the order of processing was reversed, which is how this bug was discovered. I think what's going on is that Callable[[Any], None] is compatible with Callable[[str], None] and vice-versa, so our "is_subtype" check is combining them.

One possible resolution is to only combine identical types in make_simplified_union, not "subtypes".

[JukkaL]

Currently make_simplified_union is buggy: when it combines two types, such as List[str] and List[Any], it should include the join of these types in the union instead of just dropping one of them. I think that this should fix the order dependency.

Only combining identical types is not necessarily a good answer, since Union[int, object] is logically the same type as object. If we'd modify is_same_type to consider Union[int, object] and object the same type, we might get away with having multiple representations for the same type, but this could cause trouble elsewhere -- and perhaps user confusion, unless we simplify the redundant unions when printing out types.

[ddfisher]

make_simplified_union only attempts to combine two types when one is a "subtype" of the other. It checks this using is_subtype. If this really only returned true on subtype relations, that would be correct. Instead, it returns true on is-compatible-with relations, making the simplification incorrect.

I don't think that joining the things being combined is the right fix -- instead only proper subtypes should be combined.

[JukkaL]

This seems to be fixed now that union simplification uses proper subtype checks (#3086).