Meet: Add lots of tests.

Author: davidfstr

mypy/types.py

@@ -888,7 +888,7 @@ def zipall(self, right: 'TypedDictType') \
             right_item_type = right.items.get(item_name)
             yield (item_name, left_item_type, right_item_type)
         for (item_name, right_item_type) in right.items.items():
-            if item_name not in left.items:
+            if item_name in left.items:
                 continue
             yield (item_name, None, right_item_type)
 

test-data/unit/check-typeddict.test

@@ -257,7 +257,77 @@ reveal_type(joined2)  # E: Revealed type is 'builtins.list[builtins.object*]'
 
 -- Meet
 
--- TODO: Figure out some way to trigger the TypeMeetVisitor.visit_typeddict_type() path.
+[case testMeetOfTypedDictsWithCompatibleCommonKeysHasAllKeysAndNewFallback]
+from mypy_extensions import TypedDict
+from typing import TypeVar, Callable
+XY = TypedDict('XY', {'x': int, 'y': int})
+YZ = TypedDict('YZ', {'y': int, 'z': int})
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: XY, y: YZ) -> None: pass
+reveal_type(f(g))  # E: Revealed type is 'TypedDict(x=builtins.int, y=builtins.int, z=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.int])'
+[builtins fixtures/dict.pyi]
+
+[case testMeetOfTypedDictsWithIncompatibleCommonKeysIsUninhabited]
+# flags: --strict-optional
+from mypy_extensions import TypedDict
+from typing import TypeVar, Callable
+XYa = TypedDict('XYa', {'x': int, 'y': int})
+YbZ = TypedDict('YbZ', {'y': object, 'z': int})
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: XYa, y: YbZ) -> None: pass
+reveal_type(f(g))  # E: Revealed type is '<uninhabited>'
+[builtins fixtures/dict.pyi]
+
+[case testMeetOfTypedDictsWithNoCommonKeysHasAllKeysAndNewFallback]
+from mypy_extensions import TypedDict
+from typing import TypeVar, Callable
+X = TypedDict('X', {'x': int})
+Z = TypedDict('Z', {'z': int})
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: X, y: Z) -> None: pass
+reveal_type(f(g))  # E: Revealed type is 'TypedDict(x=builtins.int, z=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.int])'
+[builtins fixtures/dict.pyi]
+
+# TODO: It would be more accurate for the meet to be TypedDict instead.
+[case testMeetOfTypedDictWithCompatibleMappingIsUninhabitedForNow]
+# flags: --strict-optional
+from mypy_extensions import TypedDict
+from typing import TypeVar, Callable, Mapping
+X = TypedDict('X', {'x': int})
+M = Mapping[str, int]
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: X, y: M) -> None: pass
+reveal_type(f(g))  # E: Revealed type is '<uninhabited>'
+[builtins fixtures/dict.pyi]
+
+[case testMeetOfTypedDictWithIncompatibleMappingIsUninhabited]
+# flags: --strict-optional
+from mypy_extensions import TypedDict
+from typing import TypeVar, Callable, Mapping
+X = TypedDict('X', {'x': int})
+M = Mapping[str, str]
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: X, y: M) -> None: pass
+reveal_type(f(g))  # E: Revealed type is '<uninhabited>'
+[builtins fixtures/dict.pyi]
+
+# TODO: It would be more accurate for the meet to be TypedDict instead.
+[case testMeetOfTypedDictWithCompatibleMappingSuperclassIsUninhabitedForNow]
+# flags: --strict-optional
+from mypy_extensions import TypedDict
+from typing import TypeVar, Callable, Iterable
+X = TypedDict('X', {'x': int})
+I = Iterable[str]
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: X, y: I) -> None: pass
+reveal_type(f(g))  # E: Revealed type is '<uninhabited>'
+[builtins fixtures/dict.pyi]
 
 
 -- Constraint Solver