Variable loses type inference after passing through dictionary of known type

[GPHemsley]

🐛 Bug Report

(Possibly related to #6755?)

When a variable is declared to be of a type including Optional, mypy correctly infers that it is not None when passing through an assert indicating as such. However, if mapped through a dictionary with a known type (either by inference or declaration), mypy loses that inference and reverts to the original type definition.

To Reproduce

from typing import (
	Dict,
	Optional,
)

def check1(x: Optional[str]) -> str:
	assert x  # x: str

	return x  # x: str

def check2(x: Optional[str]) -> str:
	assert x  # x: str

	x_map: Dict[str, str] = {
		"x": "y"
	}
	x = x_map.get(x, x)  # x: Optional[str] ??

	return x  # x: Optional[str] ??

def check3(x: Optional[str]) -> str:
	assert x  # x: str

	x_map: Dict[str, str] = {
		"x": "y"
	}
	x = x_map.get(x, x)  # x: Optional[str] ??

	assert x  # x: str

	return x  # x: str

Expected Behavior

The type of x should remain inferred as str in check2, because both possible return values from x_map.get(x, x) are known to be str.

Actual Behavior

20: error: Incompatible return value type (got "Optional[str]", expected "str")

Your Environment

• Mypy version used: mypy 0.782
• Mypy command-line flags: mypy --strict
• Python version used: Python 3.6.11

[gvanrossum]

Please look up the definition of dict.get in typeshed. Maybe there’s an explanation there?

[JelleZijlstra]

I believe that's Mapping.get: https://github.com/python/typeshed/blob/master/stdlib/3/typing.pyi#L428. It should pick the second overload, so I'm not sure why mypy puts the Optional back in.

[gvanrossum]

Perhaps this is because the type solver takes the target type (i.e. the full, declared type of x) as input, if present. In this case that's Optional[str].

The error goes away when I change the code to this:

    y = x_map.get(x, x)
    return y

A shorter, self-contained repro is:

from typing import *

T = TypeVar("T")
S = TypeVar("S")

def get(a: S, b: Union[S, T]) -> Union[S, T]: ...

def f(x: Optional[str]) -> None:
    assert x
    reveal_type(x)  # str
    y = get(x, x)
    reveal_type(y)  # str
    x = get(x, x)
    reveal_type(x)  # Optional[str]

It is the last line that is surprising.

FYI pyright has the same results. Pyre says the inferred type is str on the last line.

I'm labeling this as a bug, low priority (since there's an easy override).

[JelleZijlstra]

@adigitoleo dict.update() returns None, not a dict. Your code is incorrect.

reveal_type() still exists and should work; it may not get executed in code mypy thinks is dead.

Optional[str] means an argument that may be None, not one that may be omitted or has a default. In practice those two concepts often overlap, but conceptually they are distinct.

[adigitoleo]

@JelleZijlstra Thanks for all the info! I'll hide my comment so it's not confused with this issue.

[GPHemsley]

Some updates:

#6755 was fixed in mypy 0.930, but this was not, so probably not related.

Mapping.get was previously here:
https://github.com/python/typeshed/blob/5f9fd3d1272728a07ba7cd6cfe298151fd10d8b9/stdlib/3/typing.pyi#L428-L431
and is now here:
https://github.com/python/typeshed/blob/d45c9084a4886bc477ee171e4ef8ed3117291f32/stdlib/typing.pyi#L929-L932

Links to reproduce:
https://mypy-play.net/?mypy=master&python=3.10&flags=strict&gist=13ad6d8c4dded8cfd66298b862bbd8b8
https://mypy-play.net/?mypy=master&python=3.10&flags=strict&gist=61283a9b235cacda43ba7dcae44ea63a

[hauntsaninja]

Looks like your mypy-play link passes as of mypy 1.0.0. Fixed by #14151