[ilevkivskyi]

Fixes #7036

This adds more "fine grained" logic for overlap between TypedDict and Mapping used by overload checks and --strict-equality. Basically the rules are:

• A TypedDict with some required keys is overlapping with Mapping[str, <some type>] if and only if every key type is overlapping with <some type>.
• A TypedDict with no required keys overlaps with Mapping[str, <some type>] if and only if at least one of key types overlaps with <some type>.
• Empty dictionaries are as usual in gray area, so we follow the same logic as in other places: an empty dictionary can't cause an overlap (i.e. TypedDict with no required keys doesn't overlap with Mapping[str, <some type>]), but is itself (i.e. Mapping[<nothing>, <nothing>]) overlapping with a TypedDict with no required keys.

[silviogutierrez]

I checked this out eagerly, as I thought it covers a big use case of @cs-cordero and mine's. But now that I read it closely, it seems related but not the actual solution. That is, this still won't work:

from typing import Mapping

from mypy_extensions import TypedDict


def mapping_test(thing: Mapping[str, str]) -> bool:
    return True


class Foo(TypedDict):
    foo: str


a = Foo(foo="a")
b: Foo = {'foo': 'a'}


mapping_test(a)  # Errors out still, with below.
mapping_test(b)  # Errors out still, with below.
# Argument 1 to "mapping_test" has incompatible type "Foo"; expected "Mapping[str, str]"

You mention "overlap" but in this case, it's referring strictly to equality and overloads, not general types matching. Is that right?

Is our use case a big stretch?

Either way, thanks for all the work on mypy!

[silviogutierrez]

Adding a more thorough snippet that demonstrates what works and what doesn't as of this PR, in case it's helpful. All running with --strict-equality

from typing import Mapping

from mypy_extensions import TypedDict


def mapping_test(thing: Mapping[str, str]) -> bool:
    return True


class Foo(TypedDict):
    foo: str


a = Foo(foo="a")
b: Foo = {"foo": "a"}
c: Mapping[str, str] = {"foo": "a"}


a == b == c  # Works


mapping_test(c)  # Works, of course
mapping_test(a)  # Does not work
mapping_test(b)  # Does not work

[Michael0x2a]

I had one minor suggestion, but otherwise lgtm!

[Michael0x2a]

Maybe a third example could be - TypedDict(x=int, y=str, total=False) overlaps with Dict[str, str]`?

[ilevkivskyi]

@silviogutierrez Your issue is completely unrelated. The code is your example is unsafe because typed dicts use structural subtyping, you can use Mapping[str, object] instead.