Better match narrowing for type objects

This is the more general fix I alluded to in
#20367 (comment)

Author: hauntsaninja

mypy/checkpattern.py

@@ -569,6 +569,7 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
             return self.early_non_match()
         elif isinstance(p_typ, FunctionLike) and p_typ.is_type_obj():
             typ = fill_typevars_with_any(p_typ.type_object())
+            type_range = TypeRange(typ, is_upper_bound=False)
         elif (
             isinstance(type_info, Var)
             and type_info.type is not None
@@ -578,8 +579,10 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
             fallback = self.chk.named_type("builtins.function")
             any_type = AnyType(TypeOfAny.unannotated)
             typ = callable_with_ellipsis(any_type, ret_type=any_type, fallback=fallback)
-        elif isinstance(p_typ, TypeType) and isinstance(p_typ.item, NoneType):
+            type_range = TypeRange(typ, is_upper_bound=False)
+        elif isinstance(p_typ, TypeType):
             typ = p_typ.item
+            type_range = TypeRange(p_typ.item, is_upper_bound=True)
         elif not isinstance(p_typ, AnyType):
             self.msg.fail(
                 message_registry.CLASS_PATTERN_TYPE_REQUIRED.format(
@@ -588,9 +591,11 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
                 o,
             )
             return self.early_non_match()
+        else:
+            type_range = get_type_range(typ)
 
         new_type, rest_type = self.chk.conditional_types_with_intersection(
-            current_type, [get_type_range(typ)], o, default=current_type
+            current_type, [type_range], o, default=current_type
         )
         if is_uninhabited(new_type):
             return self.early_non_match()

test-data/unit/check-python310.test

@@ -344,19 +344,67 @@ match x:
     case [str()]:
         pass
 
-[case testMatchSequencePatternWithInvalidClassPattern]
+[case testMatchSequencePatternWithTypeObjectClassPattern]
+# flags: --strict-equality --warn-unreachable
 class Example:
     __match_args__ = ("value",)
     def __init__(self, value: str) -> None:
         self.value = value
 
-SubClass: type[Example]
+def f1(subclass: type[Example]) -> None:
+    match subclass("a"):
+        case Example(value):
+            reveal_type(value)  # N: Revealed type is "builtins.str"
+        case anything:
+            reveal_type(anything)  # E: Statement is unreachable
+
+def f2(subclass: type[Example]) -> None:
+    match Example("a"):
+        case subclass(value):
+            reveal_type(value)  # N: Revealed type is "builtins.str"
+        case anything:
+            reveal_type(anything)  # N: Revealed type is "__main__.Example"
+
+def f3(subclass: type[Example]) -> None:
+    match subclass("a"):
+        case subclass(value):
+            reveal_type(value)  # N: Revealed type is "builtins.str"
+        case anything:
+            reveal_type(anything)  # N: Revealed type is "__main__.Example"
+
+def f4(subclass: type[Example]) -> None:
+    match [subclass("a"), subclass("b")]:
+        case [subclass(value), *rest]:
+            reveal_type(value)  # N: Revealed type is "builtins.str"
+            reveal_type(rest)  # N: Revealed type is "builtins.list[__main__.Example]"
+        case anything:
+            reveal_type(anything)  # N: Revealed type is "builtins.list[__main__.Example]"
+
+class Example2:
+    __match_args__ = ("value",)
+    def __init__(self, value: str) -> None:
+        self.value = value
 
-match [SubClass("a"), SubClass("b")]:
-    case [SubClass(value), *rest]:  # E: Expected type in class pattern; found "type[__main__.Example]"
-        reveal_type(value)  # E: Cannot determine type of "value" \
-                            # N: Revealed type is "Any"
-        reveal_type(rest)  # N: Revealed type is "builtins.list[__main__.Example]"
+def f5(T: type[Example | Example2]) -> None:
+    match T("a"):
+        case Example(value):
+            reveal_type(value)  # N: Revealed type is "builtins.str"
+        case anything:
+            reveal_type(anything)  # N: Revealed type is "__main__.Example2"
+
+def f6(T: type[Example | Example2]) -> None:
+    match Example("a"):
+        case T(value):  # E: Expected type in class pattern; found "type[__main__.Example] | type[__main__.Example2]"
+            reveal_type(value)  # E: Statement is unreachable
+        case anything:
+            reveal_type(anything)  # N: Revealed type is "__main__.Example"
+
+def f7(T: type[Example | Example2]) -> None:
+    match T("a"):
+        case T(value):  # E: Expected type in class pattern; found "type[__main__.Example] | type[__main__.Example2]"
+            reveal_type(value)  # E: Statement is unreachable
+        case anything:
+            reveal_type(anything)  # N: Revealed type is "__main__.Example | __main__.Example2"
 [builtins fixtures/tuple.pyi]
 
 # Narrowing union-based values via a literal pattern on an indexed/attribute subject