Issue with TypedDict bound TypeVar in generic class

[krisz2000]

Bug Report

There seems to be a bug with TypedDict bound TypeVar used in a generic class.

To Reproduce

from typing import Generic, TypeVar, TypedDict


class A(TypedDict):
    a: str


T = TypeVar("T", bound=A)


class G(Generic[T]):
    a: str

    def foo(self, t: T) -> None:
        t["a"] = "asd"
        self.a = t["a"]

    def bar(self) -> T:
        return {"a": self.a}

Actual Behavior
In foo the first line is correct, but the second throws an error:
test.py:16: error: Incompatible types in assignment (expression has type "object", variable has type "str")

Bar throws an error too:
test.py:19: error: Incompatible return value type (got "Dict[str, str]", expected "T")

Am I missing something or is this a bug?

Your Environment

• Mypy version used: 0.920
• Mypy command-line flags: none
• Python version used: 3.9.7

[sobolevn]

Hi! Thanks for the report.

test.py:16: error: Incompatible types in assignment (expression has type "object", variable has type "str")

This does not happen anymore, try master branch to be sure.

test.py:19: error: Incompatible return value type (got "Dict[str, str]", expected "T")

Second problem is different. Right now mypy infers all {} literals to have dict type, not any specific TypedDict.

It also looks like that even this case does not work:

from typing import Generic, TypeVar, TypedDict
class A(TypedDict):
    a: str

T = TypeVar("T", bound=A)
class G(Generic[T]):
    def bar(self) -> T:
        x: T = {"a": "abc"}  # E: Incompatible types in assignment (expression has type "Dict[str, str]", variable has type "T")
        return x

I am not sure about this result. It needs some further investigation.

[erictraut]

I think the error in bar is correct. TypeVar T is bound to A, but it could be any subclass of A. You can't simply assign an A instance to a variable of type T.

Consider the following:

class A(TypedDict):
    a: str

class B(A):
    b: str

T = TypeVar("T", bound=A)

class G(Generic[T]):
    def bar(self) -> T:
        return {"a": self.a} # Error: not compatible with T

g_a = G[A]()
reveal_type(g_a.bar())  # A

g_b = G[B]()
reveal_type(g_b.bar())  # B

Note that in the final line, the correct return type for the call g_b.var() is B, but the implementation of bar is returning something that is not compatible with B.

[krisz2000]

What happens if B is defined as B(A, total=False)?
Then B is compatible with A. Still it means that every subclass of A must have total=False, and I'm not sure if it is a valid use case.

[erictraut]

@krisz2000, the total=False indicates whether the TypedDict fields are required or not required. It's not related to subtyping.

Consider the following example:

from typing import Generic, TypeVar, TypedDict

class A(TypedDict, total=False):
    a: str

T = TypeVar("T", bound=A)

class G(Generic[T]):
    def bar(self) -> T:
        return {"a": ""}

class B(A):
    c: str

g = G[B]()

v1 = g.bar()
reveal_type(v1) # B
print(v1["c"]) # Runtime exception!

I think mypy is correct in its current behavior, and I recommend closing this bug.