Minor fixes and one more test

python · JukkaL · Aug 16, 2017 · Mar 26, 2017 · Mar 26, 2017 · Mar 26, 2017
commit 8e6306f11d7ad4cf590e1399e2828d40f898e322
diff --git a/mypy/meet.py b/mypy/meet.py
@@ -92,11 +92,13 @@ class C(A, B): ...
                     return True
                 if s.type._promote and is_overlapping_types(s.type._promote, t):
                     return True
+            if t.type in s.type.mro or s.type in t.type.mro:
+                return True
             if t.type.is_protocol and is_protocol_implementation(s, t):
                 return True
             if s.type.is_protocol and is_protocol_implementation(t, s):
                 return True
-            return t.type in s.type.mro or s.type in t.type.mro
+            return False
     if isinstance(t, UnionType):
         return any(is_overlapping_types(item, s)
                    for item in t.items)

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -1505,7 +1505,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
             allow_tuple_literal = isinstance(s.lvalues[-1], (TupleExpr, ListExpr))
             s.type = self.anal_type(s.type, allow_tuple_literal)
             if (self.type and self.type.is_protocol and isinstance(lval, NameExpr) and
-                    isinstance(s.rvalue, TempNode)) and s.rvalue.no_rhs:
+                    isinstance(s.rvalue, TempNode) and s.rvalue.no_rhs):
                         if isinstance(lval.node, Var):
                             lval.node.is_abstract_var = True
         else:
@@ -1707,8 +1707,8 @@ def analyze_member_lvalue(self, lval: MemberExpr) -> None:
         if self.is_self_member_ref(lval):
             node = self.type.get(lval.name)
             if node is None or isinstance(node.node, Var) and node.node.is_abstract_var:
+                # Protocol members can't be defined via self
                 if self.type.is_protocol and node is None:
-                    # Protocol members can't be defined via self
                     self.fail("Protocol members cannot be defined via assignment to self", lval)
                 else:
                     # Implicit attribute definition in __init__.
@@ -3451,7 +3451,9 @@ def visit_file(self, file: MypyFile, fnam: str, mod_id: str, options: Options) -
                     ('__debug__', bool_type),
                 ])
             else:
-                # We are running tests
+                # We are running tests without 'bool' in builtins.
+                # TODO: Find a permanent solution to this problem.
+                # Maybe add 'bool' to all fixtures?
                 literal_types.append(('True', AnyType()))
 
             for name, typ in literal_types:

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -69,7 +69,7 @@ def is_subtype(left: Type, right: Type,
     else:
         result = left.accept(SubtypeVisitor(right, type_parameter_checker,
                                             ignore_pos_arg_names=ignore_pos_arg_names))
-        # Useful for debugging
+        # Useful for debugging:
         # print(left, right, result)
         return result
 
@@ -145,18 +145,17 @@ def visit_instance(self, left: Instance) -> bool:
             rname = right.type.fullname()
             # Always try a nominal check if possible,
             # there might be errors that a user wants to silence *once*.
-            # Also, nominal checks are faster.
-            if not left.type.has_base(rname) and rname != 'builtins.object':
-                if right.type.is_protocol:
-                    return is_protocol_implementation(left, right)
-                return False
-
-            # Map left type to corresponding right instances.
-            t = map_instance_to_supertype(left, right.type)
-
-            return all(self.check_type_parameter(lefta, righta, tvar.variance)
-                       for lefta, righta, tvar in
-                       zip(t.args, right.args, right.type.defn.type_vars))
+            if left.type.has_base(rname) or rname == 'builtins.object':
+                # Map left type to corresponding right instances.
+                t = map_instance_to_supertype(left, right.type)
+                nominal = all(self.check_type_parameter(lefta, righta, tvar.variance)
+                              for lefta, righta, tvar in
+                              zip(t.args, right.args, right.type.defn.type_vars))
+                if nominal:
+                    return True
+            if right.type.is_protocol and is_protocol_implementation(left, right):
+                return True
+            return False
         if isinstance(right, TypeType):
             item = right.item
             if isinstance(item, TupleType):
@@ -170,7 +169,7 @@ def visit_instance(self, left: Instance) -> bool:
             else:
                 return False
         if isinstance(right, CallableType):
-            # Special case: Instance can by a subtype of Callable.
+            # Special case: Instance can be a subtype of Callable.
             call = find_member('__call__', left, left)
             if call:
                 return is_subtype(call, right)
@@ -311,10 +310,8 @@ def pop_on_exit(stack: List[Tuple[Instance, Instance]],
 
 def is_protocol_implementation(left: Instance, right: Instance, allow_any: bool = True) -> bool:
     """Check whether 'left' implements the protocol 'right'. If 'allow_any' is False, then
-    check for a proper subtype. Treat recursive protocols by using a global 'assuming'
-    structural subtype matrix (in sparse representation). If concurrent type checking
-    will be implemented, then every thread/process should use its own matrix
-    (see comment in nodes.TypeInfo).
+    check for a proper subtype. Treat recursive protocols by using the 'assuming'
+    structural subtype matrix (in sparse representation), see comment in nodes.TypeInfo.
     """
     assert right.type.is_protocol
     assuming = right.type.assuming if allow_any else right.type.assuming_proper
@@ -334,7 +331,7 @@ def is_protocol_implementation(left: Instance, right: Instance, allow_any: bool
             if not subtype:
                 return False
             if allow_any:
-                # nominal check currently ignore arg names
+                # nominal check currently ignores arg names
                 is_compat = is_subtype(subtype, supertype, ignore_pos_arg_names=True)
             else:
                 is_compat = is_proper_subtype(subtype, supertype)
@@ -350,6 +347,9 @@ def is_protocol_implementation(left: Instance, right: Instance, allow_any: bool
             # this rule is copied from nominal check in checker.py
             if IS_CLASS_OR_STATIC in superflags and IS_CLASS_OR_STATIC not in subflags:
                 return False
+    # This additional push serves as poor man's subtype cache.
+    # (This already gives a decent speed-up.)
+    # TODO: Implement a general fast subtype cache?
     assuming.append((left, right))
     return True
 
@@ -452,7 +452,7 @@ def map_method(method: FuncBase, itype: Instance, subtype: Instance) -> Type:
     by 'find_var_type'.
     """
     from mypy.checkmember import bind_self
-    signature = function_type(method, Instance(itype.type.mro[-1], []))
+    signature = function_type(method, fallback=Instance(itype.type.mro[-1], []))
     signature = bind_self(signature, subtype)
     itype = map_instance_to_supertype(itype, method.info)
     return expand_type_by_instance(signature, itype)
@@ -715,24 +715,23 @@ def is_proper_subtype(t: Type, s: Type) -> bool:
 
     if isinstance(t, Instance):
         if isinstance(s, Instance):
-            if s.type.is_protocol:
-                return is_protocol_implementation(t, s, allow_any=False)
-            if not t.type.has_base(s.type.fullname()):
-                return False
-
-            def check_argument(left: Type, right: Type, variance: int) -> bool:
-                if variance == COVARIANT:
-                    return is_proper_subtype(left, right)
-                elif variance == CONTRAVARIANT:
-                    return is_proper_subtype(right, left)
-                else:
-                    return sametypes.is_same_type(left, right)
-
-            # Map left type to corresponding right instances.
-            t = map_instance_to_supertype(t, s.type)
-
-            return all(check_argument(ta, ra, tvar.variance) for ta, ra, tvar in
-                       zip(t.args, s.args, s.type.defn.type_vars))
+            if t.type.has_base(s.type.fullname()):
+                def check_argument(left: Type, right: Type, variance: int) -> bool:
+                    if variance == COVARIANT:
+                        return is_proper_subtype(left, right)
+                    elif variance == CONTRAVARIANT:
+                        return is_proper_subtype(right, left)
+                    else:
+                        return sametypes.is_same_type(left, right)
+                # Map left type to corresponding right instances.
+                t = map_instance_to_supertype(t, s.type)
+                nominal = all(check_argument(ta, ra, tvar.variance) for ta, ra, tvar in
+                              zip(t.args, s.args, s.type.defn.type_vars))
+                if nominal:
+                    return True
+            if s.type.is_protocol and is_protocol_implementation(t, s, allow_any=False):
+                return True
+            return False
         if isinstance(s, CallableType):
             call = find_member('__call__', t, t)
             if call:

diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
@@ -289,6 +289,7 @@ reveal_type(X._make([5, 'a']))  # E: Revealed type is 'Tuple[builtins.int, built
 X._make('a b')  # E: Argument 1 to X._make has incompatible type "str"; expected Iterable[Any]\
                 # N: 'builtins.str' missing following 'typing.Iterable' protocol members:\
                 # N: __iter__
+# Note that the above will not fail with real stubs, since 'str', is a subtype of 'Iterable[str]'
 
 -- # FIX: not a proper class method
 -- x = None  # type: X