allow disjoint types in Mapping.get MutableMapping.pop, dict.get, dict.pop

Author: randolf-scholz

stdlib/@tests/test_cases/builtins/check_dict.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, Generic, Iterable, Mapping, TypeVar, Union
+from typing import Any, Dict, Generic, Iterable, Literal, Mapping, TypeVar, Union
 from typing_extensions import Self, assert_type
 
 ###################################################################
@@ -74,35 +74,49 @@ def test_iterable_tuple_overload(x: Iterable[tuple[int, str]]) -> dict[int, str]
 assert_type(d_any.get("key"), Union[Any, None])
 assert_type(d_any.get("key", None), Union[Any, None])
 assert_type(d_any.get("key", any_value), Any)
-assert_type(d_any.get("key", str_value), Any)
-assert_type(d_any.get("key", int_value), Any)
+assert_type(d_any.get("key", str_value), Union[Any, str])
+assert_type(d_any.get("key", int_value), Union[Any, int])
 
 assert_type(d_str["key"], str)
 assert_type(d_str.get("key"), Union[str, None])
 assert_type(d_str.get("key", None), Union[str, None])
 # Pyright has str instead of Any here
-assert_type(d_str.get("key", any_value), Any)  # pyright: ignore[reportAssertTypeFailure]
+assert_type(d_str.get("key", any_value), Union[str, Any])
 assert_type(d_str.get("key", str_value), str)
 assert_type(d_str.get("key", int_value), Union[str, int])
 
 # Now with context!
 result: str
 result = d_any["key"]
 result = d_any.get("key")  # type: ignore[assignment]
-result = d_any.get("key", None)  # type: ignore[assignment]
+# FIXME: https://github.com/python/mypy/issues/20576 prevents using ignore[assignment] here
+result = d_any.get("key", None)  # type: ignore
 result = d_any.get("key", any_value)
 result = d_any.get("key", str_value)
-result = d_any.get("key", int_value)
+# FIXME: https://github.com/python/mypy/issues/20576 prevents using ignore[assignment] here
+result = d_any.get("key", int_value)  # type: ignore
 
 result = d_str["key"]
 result = d_str.get("key")  # type: ignore[assignment]
-result = d_str.get("key", None)  # type: ignore[assignment]
-# Pyright has str | None here, see https://github.com/microsoft/pyright/discussions/9570
-result = d_str.get("key", any_value)  # pyright: ignore[reportAssignmentType]
+# FIXME: https://github.com/python/mypy/issues/20576 prevents using ignore[assignment] here
+result = d_str.get("key", None)  # type: ignore
+result = d_str.get("key", any_value)
 result = d_str.get("key", str_value)
 result = d_str.get("key", int_value)  # type: ignore[arg-type]
 
 
+def test_get_literal(d: dict[Literal["foo", "bar"], int], dynamic_key: str) -> None:
+    # Note: annotations also allow using keys of a disjoint type (e.g., int),
+    #   linters / type checkers are free to issue warnings in such cases.
+    #   statically, a .get(arg) is superfluous if the intersection of the
+    #   dict key type and the argument type is empty.
+    #   So we only test a case with non-empty intersection here.
+
+    # check that dict wth Literal keys can get/pop a string key.
+    d.get(dynamic_key)
+    d.pop(dynamic_key)
+
+
 # Return values also make things weird
 
 # Pyright doesn't have a version of no-any-return,
@@ -140,11 +154,13 @@ def test8() -> str:
 
 
 def test9() -> str:
-    return d_str.get("key", None)  # type: ignore[return-value]
+    # FIXME: https://github.com/python/mypy/issues/20576 prevents using ignore[return-value] here
+    return d_str.get("key", None)  # type: ignore
 
 
 def test10() -> str:
-    return d_str.get("key", any_value)  # type: ignore[no-any-return]
+    # OK, return is Union[str, Any]
+    return d_str.get("key", any_value)
 
 
 def test11() -> str:

stdlib/builtins.pyi

@@ -1218,19 +1218,8 @@ class dict(MutableMapping[_KT, _VT]):
     @classmethod
     @overload
     def fromkeys(cls, iterable: Iterable[_T], value: _S, /) -> dict[_T, _S]: ...
-    # Positional-only in dict, but not in MutableMapping
-    @overload  # type: ignore[override]
-    def get(self, key: _KT, default: None = None, /) -> _VT | None: ...
-    @overload
-    def get(self, key: _KT, default: _VT, /) -> _VT: ...
-    @overload
-    def get(self, key: _KT, default: _T, /) -> _VT | _T: ...
-    @overload
-    def pop(self, key: _KT, /) -> _VT: ...
-    @overload
-    def pop(self, key: _KT, default: _VT, /) -> _VT: ...
-    @overload
-    def pop(self, key: _KT, default: _T, /) -> _VT | _T: ...
+    # get: inherited from Mapping
+    # pop: inherited from MutableMapping
     def __len__(self) -> int: ...
     def __getitem__(self, key: _KT, /) -> _VT: ...
     def __setitem__(self, key: _KT, value: _VT, /) -> None: ...

stdlib/typing.pyi

@@ -773,12 +773,10 @@ class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
     @abstractmethod
     def __getitem__(self, key: _KT, /) -> _VT_co: ...
     # Mixin methods
-    @overload
-    def get(self, key: _KT, /) -> _VT_co | None: ...
-    @overload
-    def get(self, key: _KT, default: _VT_co, /) -> _VT_co: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] # Covariant type as parameter
-    @overload
-    def get(self, key: _KT, default: _T, /) -> _VT_co | _T: ...
+    @overload  # intentionally positional-only
+    def get(self, key: Any, /) -> _VT_co | None: ...
+    @overload  # intentionally positional-only
+    def get(self, key: Any, default: _T, /) -> _VT_co | _T: ...
     def items(self) -> ItemsView[_KT, _VT_co]: ...
     def keys(self) -> KeysView[_KT]: ...
     def values(self) -> ValuesView[_VT_co]: ...
@@ -791,12 +789,10 @@ class MutableMapping(Mapping[_KT, _VT]):
     @abstractmethod
     def __delitem__(self, key: _KT, /) -> None: ...
     def clear(self) -> None: ...
-    @overload
-    def pop(self, key: _KT, /) -> _VT: ...
-    @overload
-    def pop(self, key: _KT, default: _VT, /) -> _VT: ...
-    @overload
-    def pop(self, key: _KT, default: _T, /) -> _VT | _T: ...
+    @overload  # intentionally positional-only
+    def pop(self, key: Any, /) -> _VT | None: ...
+    @overload  # intentionally positional-only
+    def pop(self, key: Any, default: _T, /) -> _VT | _T: ...
     def popitem(self) -> tuple[_KT, _VT]: ...
     # This overload should be allowed only if the value type is compatible with None.
     #