Add corner case Type[...] overlap and update tests

python · ilevkivskyi · Feb 15, 2019 · Feb 10, 2019 · Feb 10, 2019 · Feb 10, 2019
commit cad52813b0d231dad77a9543095a82212e9161ab
diff --git a/mypy/meet.py b/mypy/meet.py
@@ -221,9 +221,32 @@ def is_none_typevar_overlap(t1: Type, t2: Type) -> bool:
     # As before, we degrade into 'Instance' whenever possible.
 
     if isinstance(left, TypeType) and isinstance(right, TypeType):
-        # TODO: Can Callable[[...], T] and Type[T] be partially overlapping?
         return _is_overlapping_types(left.item, right.item)
 
+    # Type[C] vs Callable[..., C], where the latter is class object.
+    if isinstance(left, CallableType) and left.is_type_obj() and isinstance(right, TypeType):
+        if _is_overlapping_types(left.ret_type, right.item):
+            return True
+    if isinstance(right, CallableType) and right.is_type_obj() and isinstance(left, TypeType):
+        if _is_overlapping_types(right.ret_type, left.item):
+            return True
+
+    # Type[C] vs Meta, where Meta is a metaclass for C.
+    if (isinstance(left, TypeType) and isinstance(right, Instance) and
+            isinstance(left.item, Instance)):
+        left_meta = left.item.type.metaclass_type
+        if left_meta is not None and _is_overlapping_types(left_meta, right):
+                return True
+        if left_meta is None and right.type.has_base('builtins.type'):
+                return True
+    if (isinstance(right, TypeType) and isinstance(left, Instance) and
+            isinstance(right.item, Instance)):
+        right_meta = right.item.type.metaclass_type
+        if right_meta is not None and _is_overlapping_types(right_meta, left):
+                return True
+        if right_meta is None and left.type.has_base('builtins.type'):
+                return True
+
     if isinstance(left, CallableType) and isinstance(right, CallableType):
         return is_callable_compatible(left, right,
                                       is_compat=_is_overlapping_types,

diff --git a/test-data/unit/check-expressions.test b/test-data/unit/check-expressions.test
@@ -2042,7 +2042,7 @@ x is 42
 # flags: --strict-equality --strict-optional
 
 x: str
-if x is not None:  # E: Non-overlapping identity check (left operand type: "str", right operand type: "None")
+if x is not None:  # OK even with strict-optional
     pass
 [builtins fixtures/bool.pyi]
 
@@ -2086,3 +2086,36 @@ class A:
 # Don't report non-overlapping check if there is already and error.
 42 in A()  # E: Unsupported operand types for in ("int" and "A")
 [builtins fixtures/bool.pyi]
+
+[case testStrictEqualityTypeVsCallable]
+# flags: --strict-equality
+from typing import Type, List
+class C: ...
+class D(C): ...
+class Bad: ...
+
+subclasses: List[Type[C]]
+C in subclasses
+D in subclasses
+Bad in subclasses  # E: Non-overlapping container check (element type: "Type[Bad]", container item type: "Type[C]")
+[builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testStrictEqualityMetaclass]
+# flags: --strict-equality
+from typing import List, Type
+
+class Meta(type): ...
+
+class A(metaclass=Meta): ...
+class B(metaclass=Meta): ...
+class C: ...
+
+o: Type[object]
+exp: List[Meta]

+A in exp
+C in exp  # E: Non-overlapping container check (element type: "Type[C]", container item type: "Meta")
+o in exp
+[builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]