Fix overload resolution with ducktype compatibility

Ignore ducktype compatibility (e.g. int being compatible with float)
when determining which overload variant to pick, since ducktype
declarations are not honored by isinstance().

Fixes #410.

Author: JukkaL

mypy/checkexpr.py

@@ -26,7 +26,7 @@
 from mypy.infer import infer_type_arguments, infer_function_type_arguments
 from mypy import join
 from mypy.expandtype import expand_type, expand_caller_var_args
-from mypy.subtypes import is_subtype
+from mypy.subtypes import is_subtype, is_more_precise
 from mypy import applytype
 from mypy import erasetype
 from mypy.checkmember import analyse_member_access, type_object_type
@@ -602,15 +602,19 @@ def matches_signature_erased(self, arg_types: List[Type], is_var_arg: bool,
         # Fixed function arguments.
         func_fixed = callee.max_fixed_args()
         for i in range(min(len(arg_types), func_fixed)):
-            if not is_subtype(self.erase(arg_types[i]),
-                              self.erase(
-                                  callee.arg_types[i])):
+            # Use is_more_precise rather than is_subtype because it ignores ducktype
+            # declarations. This is important since ducktype declarations are ignored
+            # when performing runtime type checking.
+            if not is_more_precise(self.erase(arg_types[i]),
+                                   self.erase(
+                                       callee.arg_types[i])):
                 return False
         # Function varargs.
         if callee.is_var_arg:
             for i in range(func_fixed, len(arg_types)):
-                if not is_subtype(self.erase(arg_types[i]),
-                                  self.erase(callee.arg_types[func_fixed])):
+                # See above for why we use is_more_precise.
+                if not is_more_precise(self.erase(arg_types[i]),
+                                       self.erase(callee.arg_types[func_fixed])):
                     return False
         return True
 

mypy/subtypes.py

@@ -287,5 +287,8 @@ def is_more_precise(t: Type, s: Type) -> bool:
     if isinstance(s, AnyType):
         return True
     if isinstance(s, Instance):
+        if isinstance(t, Callable):
+            # Fall back to subclass check and ignore other properties of the callable.
+            return is_proper_subtype(t.fallback, s)
         return is_proper_subtype(t, s)
     return sametypes.is_same_type(t, s)

mypy/test/data/check-overloading.test

@@ -476,3 +476,23 @@ main: In class "B":
 main, line 12: Signature of "f" incompatible with supertype "A"
 main: In class "C":
 main, line 17: Signature of "f" incompatible with supertype "A"
+
+[case testOverloadingAndDucktypeCompatibility]
+from typing import overload, ducktype, builtinclass
+
+@builtinclass
+class A: pass
+
+@builtinclass
+@ducktype(A)
+class B: pass
+
+@overload
+def f(n: B) -> B:
+    return n
+@overload
+def f(n: A) -> A:
+    return n
+
+f(B()) + 'x'  # E: Unsupported left operand type for + ("B")
+f(A()) + 'x'  # E: Unsupported left operand type for + ("A")