Make overload definitions always strict optional

Author: Michael0x2a

mypy/checker.py

@@ -414,53 +414,56 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
     def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
         # At this point we should have set the impl already, and all remaining
         # items are decorators
-        for i, item in enumerate(defn.items):
-            # TODO overloads involving decorators
-            assert isinstance(item, Decorator)
-            sig1 = self.function_type(item.func)
+        with experiments.strict_optional_set(True):
+            for i, item in enumerate(defn.items):
+                # TODO overloads involving decorators
+                assert isinstance(item, Decorator)
+                sig1 = self.function_type(item.func)
 
-            for j, item2 in enumerate(defn.items[i + 1:]):
-                assert isinstance(item2, Decorator)
-                sig2 = self.function_type(item2.func)
+                for j, item2 in enumerate(defn.items[i + 1:]):
+                    assert isinstance(item2, Decorator)
+                    sig2 = self.function_type(item2.func)
 
-                assert isinstance(sig1, CallableType)
-                assert isinstance(sig2, CallableType)
+                    assert isinstance(sig1, CallableType)
+                    assert isinstance(sig2, CallableType)
 
-                if not are_argument_counts_overlapping(sig1, sig2):
-                    continue
-
-                if if_overload_can_never_match(sig1, sig2):
-                    self.msg.overloaded_signature_will_never_match(i + 1, i + j + 2, item2.func)
-                elif is_unsafe_overlapping_overload_signatures(sig1, sig2):
-                    self.msg.overloaded_signatures_overlap(i + 1, i + j + 2, item.func)
-            if defn.impl:
-                if isinstance(defn.impl, FuncDef):
-                    impl_type = defn.impl.type
-                elif isinstance(defn.impl, Decorator):
-                    impl_type = defn.impl.var.type
-                else:
-                    assert False, "Impl isn't the right type"
-                # This can happen if we've got an overload with a different
-                # decorator too -- we gave up on the types.
-                if impl_type is None or isinstance(impl_type, AnyType) or sig1 is None:
-                    return
+                    if not are_argument_counts_overlapping(sig1, sig2):
+                        continue
 
-                assert isinstance(impl_type, CallableType)
-                assert isinstance(sig1, CallableType)
-                if not is_callable_compatible(impl_type, sig1,
-                                              is_compat=is_subtype, ignore_return=True):
-                    self.msg.overloaded_signatures_arg_specific(i + 1, defn.impl)
-                impl_type_subst = impl_type
-                if impl_type.variables:
-                    unified = unify_generic_callable(impl_type, sig1, ignore_return=False)
-                    if unified is None:
-                        self.fail("Type variable mismatch between " +
-                                  "overload signature {} and implementation".format(i + 1),
-                                  defn.impl)
+                    if overload_can_never_match(sig1, sig2):
+                        self.msg.overloaded_signature_will_never_match(
+                            i + 1, i + j + 2, item2.func)
+                    elif is_unsafe_overlapping_overload_signatures(sig1, sig2):
+                        self.msg.overloaded_signatures_overlap(
+                            i + 1, i + j + 2, item.func)
+                if defn.impl:
+                    if isinstance(defn.impl, FuncDef):
+                        impl_type = defn.impl.type
+                    elif isinstance(defn.impl, Decorator):
+                        impl_type = defn.impl.var.type
+                    else:
+                        assert False, "Impl isn't the right type"
+                    # This can happen if we've got an overload with a different
+                    # decorator too -- we gave up on the types.
+                    if impl_type is None or isinstance(impl_type, AnyType) or sig1 is None:
                         return
-                    impl_type_subst = unified
-                if not is_subtype(sig1.ret_type, impl_type_subst.ret_type):
-                    self.msg.overloaded_signatures_ret_specific(i + 1, defn.impl)
+
+                    assert isinstance(impl_type, CallableType)
+                    assert isinstance(sig1, CallableType)
+                    if not is_callable_compatible(impl_type, sig1,
+                                                  is_compat=is_subtype, ignore_return=True):
+                        self.msg.overloaded_signatures_arg_specific(i + 1, defn.impl)
+                    impl_type_subst = impl_type
+                    if impl_type.variables:
+                        unified = unify_generic_callable(impl_type, sig1, ignore_return=False)
+                        if unified is None:
+                            self.fail("Type variable mismatch between " +
+                                      "overload signature {} and implementation".format(i + 1),
+                                      defn.impl)
+                            return
+                        impl_type_subst = unified
+                    if not is_subtype(sig1.ret_type, impl_type_subst.ret_type):
+                        self.msg.overloaded_signatures_ret_specific(i + 1, defn.impl)
 
     # Here's the scoop about generators and coroutines.
     #
@@ -3618,7 +3621,7 @@ def is_unsafe_overlapping_overload_signatures(signature: CallableType,
                                    is_compat_return=lambda l, r: not is_subtype(r, l)))
 
 
-def if_overload_can_never_match(signature: CallableType, other: CallableType) -> bool:
+def overload_can_never_match(signature: CallableType, other: CallableType) -> bool:
     """Check if the 'other' method can never be matched due to 'signature'.
 
     This can happen if signature's parameters are all strictly broader then

mypy/checkexpr.py

@@ -1152,9 +1152,6 @@ def check_overload_call(self,
             # TODO: Adjust the error message here to make it clear there was no match.
             target = erased_targets[0]
 
-        '''target = self.overload_call_target(args, arg_types, arg_kinds, arg_names,
-                                           callee, context,
-                                           messages=arg_messages)'''
         return self.check_call(target, args, arg_kinds, context, arg_names,
                                arg_messages=arg_messages,
                                callable_name=callable_name,
@@ -1209,7 +1206,6 @@ def infer_overload_return_type(self,
             try:
                 # Passing `overload_messages` as the `arg_messages` parameter doesn't
                 # seem to reliably catch all possible errors.
-                #
                 # TODO: Figure out why
                 result = self.check_call(
                     callee=typ,

test-data/unit/check-overloading.test

@@ -1848,3 +1848,102 @@ reveal_type(f(obj1))  # E: Revealed type is '__main__.A'
 obj2: Union[Wrapper1[A], Wrapper2[B]]
 reveal_type(f(obj2))  # E: Revealed type is 'Union[__main__.A, __main__.B]'
 
+[case testOverloadsAndNoneWithoutStrictOptional]
+# flags: --no-strict-optional
+from typing import overload, Optional
+
+@overload
+def f(x: None) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def f(x: object) -> str: ...
+def f(x): ...
+
+# We pretend strict-optional is enabled for overload definitions,
+# even in non-strict optional mode
+@overload
+def g(x: None) -> int: ...
+@overload
+def g(x: int) -> str: ...
+def g(x): ...
+
+# Calls are still checked normally though
+a: None
+b: int
+c: Optional[int]
+reveal_type(g(a))  # E: Revealed type is 'builtins.int'
+reveal_type(g(b))  # E: Revealed type is 'builtins.str'
+reveal_type(g(c))  # E: Revealed type is 'builtins.str'
+
+[case testOverloadsAndNoneWithStrictOptional]
+# flags: --strict-optional
+from typing import overload, Optional
+
+@overload
+def f(x: None) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def f(x: object) -> str: ...
+def f(x): ...
+
+@overload
+def g(x: None) -> int: ...
+@overload
+def g(x: int) -> str: ...
+def g(x): ...
+
+a: None
+b: int
+c: Optional[int]
+reveal_type(g(a))  # E: Revealed type is 'builtins.int'
+reveal_type(g(b))  # E: Revealed type is 'builtins.str'
+reveal_type(g(c))  # E: Revealed type is 'Union[builtins.int, builtins.str]'
+
+[case testOverloadsNoneAndTypeVarsWithNoStrictOptional]
+# flags: --no-strict-optional
+from typing import Callable, Iterable, TypeVar, overload, Optional
+
+T = TypeVar('T')
+S = TypeVar('S')
+
+@overload
+def mymap(func: None, seq: Iterable[T]) -> Iterable[T]: ...
+@overload
+def mymap(func: Callable[[T], S], seq: Iterable[T]) -> Iterable[S]: ...
+def mymap(*args): ...
+
+seq = [1, 2, 3]
+f1: Callable[[int], str]
+f2: None
+f3: Optional[Callable[[int], str]]
+
+reveal_type(mymap(f1, seq))  # E: Revealed type is 'typing.Iterable[builtins.str*]'
+reveal_type(mymap(f2, seq))  # E: Revealed type is 'typing.Iterable[builtins.int*]'
+reveal_type(mymap(f3, seq))  # E: Revealed type is 'typing.Iterable[builtins.str*]'
+
+[builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testOverloadsNoneAndTypeVarsWithStrictOptional]
+# flags: --strict-optional
+from typing import Callable, Iterable, TypeVar, overload, Optional
+
+T = TypeVar('T')
+S = TypeVar('S')
+
+@overload
+def mymap(func: None, seq: Iterable[T]) -> Iterable[T]: ...
+@overload
+def mymap(func: Callable[[T], S], seq: Iterable[T]) -> Iterable[S]: ...
+def mymap(*args): ...
+
+seq = [1, 2, 3]
+f1: Callable[[int], str]
+f2: None
+f3: Optional[Callable[[int], str]]
+
+reveal_type(mymap(f1, seq))  # E: Revealed type is 'typing.Iterable[builtins.str*]'
+reveal_type(mymap(f2, seq))  # E: Revealed type is 'typing.Iterable[builtins.int*]'
+reveal_type(mymap(f3, seq))  # E: Revealed type is 'Union[typing.Iterable[builtins.int], typing.Iterable[builtins.str]]'
+
+[builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]
+