Merge branch 'fix-overload-resolution'

Author: JukkaL

mypy/checkexpr.py

@@ -605,16 +605,14 @@ def matches_signature_erased(self, arg_types: List[Type], is_var_arg: bool,
             # 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])):
+            if not is_compatible_overload_arg(arg_types[i], callee.arg_types[i]):
                 return False
         # Function varargs.
         if callee.is_var_arg:
             for i in range(func_fixed, len(arg_types)):
                 # 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])):
+                if not is_compatible_overload_arg(arg_types[i],
+                                                  callee.arg_types[func_fixed]):
                     return False
         return True
 
@@ -1250,10 +1248,6 @@ def unwrap_list(self, a: List[Node]) -> List[Node]:
             r.append(self.strip_parens(n))
         return r
 
-    def erase(self, type: Type) -> Type:
-        """Replace type variable types in type with Any."""
-        return erasetype.erase_type(type)
-
 
 def is_valid_argc(nargs: int, is_var_arg: bool, callable: Callable) -> bool:
     """Return a boolean indicating whether a call expression has a
@@ -1401,3 +1395,30 @@ def __init__(self) -> None:
 
     def visit_erased_type(self, t: ErasedType) -> bool:
         return True
+
+
+def is_compatible_overload_arg(actual: Type, formal: Type) -> bool:
+    if (isinstance(actual, NoneTyp) or isinstance(actual, AnyType) or
+            isinstance(formal, AnyType) or isinstance(formal, TypeVar) or
+            isinstance(formal, Callable)):
+        # These could match anything at runtime.
+        return True
+    if isinstance(actual, UnionType):
+        return any(is_compatible_overload_arg(item, formal)
+                   for item in actual.items)
+    if isinstance(formal, UnionType):
+        return any(is_compatible_overload_arg(actual, item)
+                   for item in formal.items)
+    if isinstance(formal, Instance):
+        if isinstance(actual, Callable):
+            actual = actual.fallback
+        if isinstance(actual, Overloaded):
+            actual = actual.items()[0].fallback
+        if isinstance(actual, TupleType):
+            actual = actual.fallback
+        if isinstance(actual, Instance):
+            return formal.type in actual.type.mro
+        else:
+            return False
+    # Fall back to a conservative equality check for the remaining kinds of type.
+    return is_same_type(erasetype.erase_type(actual), erasetype.erase_type(formal))

mypy/meet.py

@@ -71,7 +71,13 @@ def is_overlapping_types(t: Type, s: Type) -> bool:
             if tbuiltin in sbuiltin.mro or sbuiltin in tbuiltin.mro:
                 return True
             return tbuiltin == sbuiltin
-    # We conservatively assume that non-instance types can overlap any other
+    if isinstance(t, UnionType):
+        return any(is_overlapping_types(item, s)
+                   for item in t.items)
+    if isinstance(s, UnionType):
+        return any(is_overlapping_types(t, item)
+                   for item in s.items)
+    # We conservatively assume that non-instance, non-union types can overlap any other
     # types.
     return True
 

mypy/test/data/check-unions.test

@@ -79,10 +79,21 @@ i = y.foo()   # E: Incompatible types in assignment (expression has type "Union[
 
 [case testUnionIndexing]
 from typing import Union, List, Undefined
-
 x = Undefined # type: Union[List[int], str]
 x[2]
 x[2] + 1 # E: Unsupported operand types for + (likely involving Union)
-
-
 [builtins fixtures/isinstancelist.py]
+
+[case testUnionAsOverloadArg]
+from typing import Union, overload
+@overload
+def f(x: Union[int, str]) -> int: pass
+@overload
+def f(x: type) -> str: pass
+x = 0
+x = f(1)
+x = f('')
+s = ''
+s = f(int)
+s = f(1)    # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+x = f(int)  # E: Incompatible types in assignment (expression has type "str", variable has type "int")

mypy/test/data/python2eval.test

@@ -247,3 +247,14 @@ print f('ab')
 [out]
 12
 ab
+
+[case testStrAdd_python2]
+import typing
+s = ''
+u = u''
+n = 0
+n = s + '' # E
+s = s + u'' # E
+[out]
+_program.py, line 5: Incompatible types in assignment (expression has type "str", variable has type "int")
+_program.py, line 6: Incompatible types in assignment (expression has type "unicode", variable has type "str")

mypy/test/data/pythoneval.test

@@ -919,3 +919,11 @@ map(f, ['x'])
 map(f, [1])
 [out]
 _program.py, line 4: Argument 1 to "map" has incompatible type Function[["str"] -> "str"]; expected Function[["int"] -> "str"]
+
+[case testMapStr]
+import typing
+x = range(3)
+a = list(map(str, x))
+a + 1
+[out]
+_program.py, line 4: Unsupported operand types for + (List[str] and "int")

stubs/2.7/builtins.py

@@ -4,7 +4,7 @@
     Undefined, typevar, AbstractGeneric, Iterator, Iterable, overload,
     Sequence, Mapping, Tuple, List, Any, Dict, Function, Generic, Set,
     AbstractSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,
-    SupportsRound, IO, BinaryIO, builtinclass, ducktype
+    SupportsRound, IO, BinaryIO, builtinclass, ducktype, Union
 )
 from abc import abstractmethod, ABCMeta
 
@@ -152,8 +152,12 @@ def __init__(self) -> None: pass
     @overload
     def __init__(self, o: object) -> None: pass
     @overload
+    def __init__(self, o: str, encoding: str = None, errors: str = 'strict') -> None: pass
+    @overload
     def __init__(self, o: str, encoding: unicode = None, errors: unicode = 'strict') -> None: pass
     @overload
+    def __init__(self, o: bytearray, encoding: str = None, errors: str = 'strict') -> None: pass
+    @overload
     def __init__(self, o: bytearray, encoding: unicode = None,
                  errors: unicode = 'strict') -> None: pass
     def capitalize(self) -> unicode: pass
@@ -232,37 +236,14 @@ def __hash__(self) -> int: pass
 class str(Sequence[str]):
     def __init__(self, object: object) -> None: pass
     def capitalize(self) -> str: pass
-    @overload
-    def center(self, width: int, fillchar: str = None) -> str: pass
-    @overload
-    def center(self, width: int, fillchar: bytearray = None) -> str: pass
-    @overload
-    def count(self, x: unicode) -> int: pass
-    @overload
-    def count(self, x: bytearray) -> int: pass
+    def center(self, width: int, fillchar: Union[str, bytearray] = None) -> str: pass
+    def count(self, x: Union[unicode, bytearray]) -> int: pass
     def decode(self, encoding: unicode = 'utf-8', errors: unicode = 'strict') -> unicode: pass
     def encode(self, encoding: unicode = 'utf-8', errors: unicode = 'strict') -> str: pass
-    @overload
-    def endswith(self, suffix: unicode) -> bool: pass
-    @overload
-    def endswith(self, suffix: bytearray) -> bool: pass
+    def endswith(self, suffix: Union[unicode, bytearray]) -> bool: pass
     def expandtabs(self, tabsize: int = 8) -> str: pass
-    @overload
-    def find(self, sub: unicode, start: int = 0) -> int: pass
-    @overload
-    def find(self, sub: unicode, start: int, end: int) -> int: pass
-    @overload
-    def find(self, sub: bytearray, start: int = 0) -> int: pass
-    @overload
-    def find(self, sub: bytearray, start: int, end: int) -> int: pass
-    @overload
-    def index(self, sub: unicode, start: int = 0) -> int: pass
-    @overload
-    def index(self, sub: unicode, start: int, end: int) -> int: pass
-    @overload
-    def index(self, sub: bytearray, start: int = 0) -> int: pass
-    @overload
-    def index(self, sub: bytearray, start: int, end: int) -> int: pass
+    def find(self, sub: Union[unicode, bytearray], start: int = 0, end: int = 0) -> int: pass
+    def index(self, sub: Union[unicode, bytearray], start: int = 0, end: int = 0) -> int: pass
     def isalnum(self) -> bool: pass
     def isalpha(self) -> bool: pass
     def isdigit(self) -> bool: pass
@@ -274,10 +255,7 @@ def isupper(self) -> bool: pass
     def join(self, iterable: Iterable[str]) -> str: pass  # TODO unicode
     @overload
     def join(self, iterable: Iterable[bytearray]) -> str: pass
-    @overload
-    def ljust(self, width: int, fillchar: str = None) -> str: pass
-    @overload
-    def ljust(self, width: int, fillchar: bytearray = None) -> str: pass
+    def ljust(self, width: int, fillchar: Union[str, bytearray] = None) -> str: pass
     def lower(self) -> str: pass
     @overload
     def lstrip(self, chars: str = None) -> str: pass   # TODO unicode
@@ -307,10 +285,7 @@ def rindex(self, sub: unicode, start: int, end: int) -> int: pass
     def rindex(self, sub: bytearray, start: int = 0) -> int: pass
     @overload
     def rindex(self, sub: bytearray, start: int, end: int) -> int: pass
-    @overload
-    def rjust(self, width: int, fillchar: str = None) -> str: pass
-    @overload
-    def rjust(self, width: int, fillchar: bytearray = None) -> str: pass
+    def rjust(self, width: int, fillchar: Union[str, bytearray] = None) -> str: pass
     @overload
     def rpartition(self, sep: str) -> Tuple[str, str, str]: pass  # TODO unicode
     @overload
@@ -331,10 +306,7 @@ def split(self, sep: str = None, maxsplit: int = -1) -> List[str]: pass   # TODO
     def split(self, sep: bytearray = None,     # TODO unicode
               maxsplit: int = -1) -> List[str]: pass
     def splitlines(self, keepends: bool = False) -> List[str]: pass
-    @overload
-    def startswith(self, prefix: unicode) -> bool: pass
-    @overload
-    def startswith(self, prefix: bytearray) -> bool: pass
+    def startswith(self, prefix: Union[unicode, bytearray]) -> bool: pass
     @overload
     def strip(self, chars: str = None) -> str: pass   # TODO unicode
     @overload
@@ -363,9 +335,11 @@ def __getitem__(self, i: int) -> str: pass
     def __getitem__(self, s: slice) -> str: pass
     def __getslice__(self, start: int, stop: int) -> str: pass
     @overload
-    def __add__(self, s: str) -> str: pass    # TODO unicode
+    def __add__(self, s: str) -> str: pass
     @overload
     def __add__(self, s: bytearray) -> str: pass
+    @overload
+    def __add__(self, s: unicode) -> unicode: pass
     def __mul__(self, n: int) -> str: pass
     def __rmul__(self, n: int) -> str: pass
     def __contains__(self, o: object) -> bool: pass
@@ -799,9 +773,11 @@ def next(i: Iterator[_T]) -> _T: pass
 def next(i: Iterator[_T], default: _T) -> _T: pass
 def oct(i: int) -> str: pass  # TODO __index__
 @overload
-def open(file: unicode, mode: unicode = 'r', buffering: int = -1) -> BinaryIO: pass
+def open(file: str, mode: str = 'r', buffering: int = -1) -> BinaryIO: pass
+@overload
+def open(file: unicode, mode: str = 'r', buffering: int = -1) -> BinaryIO: pass
 @overload
-def open(file: int, mode: unicode = 'r', buffering: int = -1) -> BinaryIO: pass
+def open(file: int, mode: str = 'r', buffering: int = -1) -> BinaryIO: pass
 @overload
 def ord(c: unicode) -> int: pass
 @overload

travis.sh

@@ -24,6 +24,7 @@ echo tests.py
 for t in mypy.test.testpythoneval; do
     echo $t
     "$PYTHON" "$DRIVER" -m $t || fail
+    "$PYTHON" -m $t || fail
 done
 
 # Stub checks