Can't infer T where Optional[T] is Optional[MyUnion]

• Are you reporting a bug, or opening a feature request?

Bug

• Please insert below the code you are checking with mypy,
  or a mock-up repro if the source is private. We would appreciate
  if you try to simplify your case to a minimal repro.

from typing import Optional, Union, TypeVar

MyUnion = Union[int, str]
T = TypeVar("T")


def not_none(x: Optional[T]) -> T:
    assert x is not None
    return x


# Works
def f(i: Optional[int]) -> int:
    return not_none(i)


# Doesn't work
def g(u: Optional[MyUnion]) -> MyUnion:
    return not_none(u)

• What is the actual behavior/output?

a.py:19: error: Incompatible return value type (got "object", expected "Union[int, str]")

• What is the behavior/output you expect?

No error.

• What are the versions of mypy and Python you are using?
  Do you see the same issue after installing mypy from Git master?

mypy --version is 0.710+dev.70a4c9858fb3e736dbf4bc6cc9243c5d49bf2e5a
py --version is Python 3.7.2
Still see the issue after installing from master.

• What are the mypy flags you are using? (For example --strict-optional)

None

[ilevkivskyi]

I bet this is because of some hacky special-casing for how we infer constrains to union types. Likely Union[None, T] :> Union[None, int, str] infers T :> int; T :> str which is solved as T = object. Potentially this may be fixed by removing common items from unions when inferring union against union. I didn't think much about this however.

A possibly related issue:

from typing import cast, Optional, Type, TypeVar

T = TypeVar("T")

def my_cast(t: Type[T], o: object) -> T:
    return cast(T, o)

def f(b: bool) -> Optional[int]:
    if b:
        # Works
        return cast(Optional[int], 42)
    else:
        # Doesn't work
        return my_cast(Optional[int], 42)

> mypy --strict a.py
a.py:14: error: Returning Any from function declared to return "Optional[int]"

[JelleZijlstra]

I think this is different; this is because Union is not actually a type that you can use Type[] on.

[glyph]

If this helps prioritize it at all, we've bumped into this a few times in quite rapid succession; inferring that the parent of Union[X, Y, None] and Union[X, Y] is object makes it difficult to write helpers like the aforementioned not_none without resorting to hacky workarounds and casts.

[svenpanne]

I think I've run into the original problem as well:

rom typing import Callable, TypeVar, Union

class A: pass
class B(A): pass
class C(A): pass

value: Union[B, C] = C()

T = TypeVar("T")
Promise = Union[T, Callable[[], T]]

def force(p: Promise[T]) -> T:
    return p() if callable(p) else p

reveal_type(force(value))  # actual: A, expected Union[B, C]

The only real difference here is that the Callable is being "stripped away" instead of None.

Can we somehow bump the priority? This bug is effectively a blocker for small (but important!) helper functions like force or not_none, which are very common.