improve narrowing + better tests

Author: randolf-scholz

mypy/checker.py

@@ -8015,11 +8015,16 @@ def conditional_types(
             # attempt to narrow anything. Instead, we broaden the expr to Any to
             # avoid false positives
             return proposed_type, default
-        elif not any(
+        elif not any(  #  handle concrete subtypes
             type_range.is_upper_bound for type_range in proposed_type_ranges
         ) and is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
             # Expression is always of one of the types in proposed_type_ranges
             return default, UninhabitedType()
+        elif (  # handle structural subtypes
+            isinstance(proposed_type, CallableType)
+            or (isinstance(proposed_type, Instance) and proposed_type.type.runtime_protocol)
+        ) and is_subtype(current_type, proposed_type, ignore_promotions=True):
+            return default, UninhabitedType()
         elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
             # Expression is never of any type in proposed_type_ranges
             return UninhabitedType(), default

mypy/checkpattern.py

@@ -562,9 +562,7 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
             # Create a `Callable[..., Any]`
             fallback = self.chk.named_type("builtins.function")
             any_type = AnyType(TypeOfAny.unannotated)
-            fn_type = callable_with_ellipsis(any_type, ret_type=any_type, fallback=fallback)
-            # if typ is itself callable, use its own type, otherwise Callable[..,, Any]
-            typ = current_type if is_subtype(current_type, fn_type) else fn_type
+            typ = callable_with_ellipsis(any_type, ret_type=any_type, fallback=fallback)
         else:
             if isinstance(type_info, Var) and type_info.type is not None:
                 name = type_info.type.str_with_options(self.options)

test-data/unit/check-protocols.test

@@ -1506,11 +1506,12 @@ class C: pass
 def f(x: P1) -> int: ...
 @overload
 def f(x: P2) -> str: ...
-def f(x):
+def f(x: object) -> object:
     if isinstance(x, P1):
         return P1.attr1
     if isinstance(x, P2): # E: Only @runtime_checkable protocols can be used with instance and class checks
-        return P1.attr2
+        return P2.attr2
+    return None
 
 reveal_type(f(C1())) # N: Revealed type is "builtins.int"
 reveal_type(f(C2())) # N: Revealed type is "builtins.str"

test-data/unit/check-python310.test

@@ -1072,18 +1072,36 @@ match m:
 [case testMatchClassPatternCallable]
 from typing import Callable
 
-x: object
+def test_object(x: object) -> None:
+    match x:
+        case Callable() as fn:
+            reveal_type(fn)  # N: Revealed type is "def (*Any, **Any) -> Any"
 
-match x:
-    case Callable() as fn:
-        reveal_type(fn)  # N: Revealed type is "def (*Any, **Any) -> Any"
+def test_intfun(x: Callable[[int], int]) -> None:
+    match x:
+        case Callable() as fn:
+            reveal_type(fn)  # N: Revealed type is "def (builtins.int) -> builtins.int"
 
-def int_fun(x: int) -> int: return x+1
 
-match int_fun:
-    case Callable() as fn:
-        reveal_type(fn)  # N: Revealed type is "def (x: builtins.int) -> builtins.int"
+[case testMatchClassPatternCallbackProtocol]
+from typing import Any, Callable
+from typing_extensions import Protocol, runtime_checkable
 
+@runtime_checkable
+class AnyCallable(Protocol):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+def test_object(x: object) -> None:
+    match x:
+        case AnyCallable() as fn:
+            reveal_type(fn)  # N: Revealed type is "__main__.AnyCallable"
+
+def test_intfun(x: Callable[[int], int]) -> None:
+    match x:
+        case AnyCallable() as fn:
+            reveal_type(fn)  # N: Revealed type is "def (builtins.int) -> builtins.int"
+
+[builtins fixtures/dict.pyi]
 
 [case testMatchClassPatternNestedGenerics]
 # From cpython test_patma.py