Fix overload handling with union types in signatures

Previously `None` was not considered as more precise than
`Optional[x]`, which was obviously incorrect. Fixed the
implementation of type precision checking to match the
description, how that proper subtype checking works.

Fixes the original example in #3295.

Author: JukkaL

mypy/subtypes.py

@@ -720,4 +720,4 @@ def is_more_precise(t: Type, s: Type) -> bool:
             # 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)
+    return is_proper_subtype(t, s)

mypy/test/testtypes.py

@@ -175,11 +175,11 @@ def test_is_more_precise(self) -> None:
         assert_true(is_more_precise(fx.b, fx.anyt))
         assert_true(is_more_precise(self.tuple(fx.b, fx.a),
                                     self.tuple(fx.b, fx.a)))
+        assert_true(is_more_precise(self.tuple(fx.b, fx.b),
+                                    self.tuple(fx.b, fx.a)))
 
         assert_false(is_more_precise(fx.a, fx.b))
         assert_false(is_more_precise(fx.anyt, fx.b))
-        assert_false(is_more_precise(self.tuple(fx.b, fx.b),
-                                     self.tuple(fx.b, fx.a)))
 
     # is_proper_subtype
 

test-data/unit/check-optional.test

@@ -596,3 +596,18 @@ x: Optional[Union[int, str]]
 reveal_type(x) # E: Revealed type is 'Union[builtins.int, builtins.str, builtins.None]'
 y: Optional[Union[int, None]]
 reveal_type(y) # E: Revealed type is 'Union[builtins.int, builtins.None]'
+
+[case testOverloadWithNoneAndOptional]
+from typing import overload, Optional
+
+@overload
+def f(x: int) -> str: ...
+@overload
+def f(x: Optional[int]) -> Optional[str]: ...
+def f(x): return x
+
+reveal_type(f(1))
+reveal_type(f(None))
+[out]
+main:9: error: Revealed type is 'builtins.str'
+main:10: error: Revealed type is 'Union[builtins.str, builtins.None]'