Avoid narrowing type[T] (#20662)

Maybe a little ad hoc, but avoids some of the undesirable primer
regression from #20492

Closes #20636

Author: hauntsaninja

mypy/checker.py

@@ -6492,10 +6492,13 @@ def comparison_type_narrowing_helper(self, node: ComparisonExpr) -> tuple[TypeMa
                 and not is_false_literal(expr)
                 and not is_true_literal(expr)
                 and not self.is_literal_enum(expr)
+                # CallableType type objects are usually already maximally specific
                 and not (
                     isinstance(p_expr := get_proper_type(expr_type), CallableType)
                     and p_expr.is_type_obj()
                 )
+                # This is a little ad hoc, in the absence of intersection types
+                and not (isinstance(p_expr, TypeType) and isinstance(p_expr.item, TypeVarType))
             ):
                 h = literal_hash(expr)
                 if h is not None:

test-data/unit/check-narrowing.test

@@ -3018,6 +3018,60 @@ def f2(x: Any) -> None:
     reveal_type(x)  # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
 
+[case testNarrowTypeObject]
+# flags: --strict-equality --warn-unreachable
+from typing import Any
+
+# https://github.com/python/mypy/issues/13704
+
+def f1(cls: type):
+    if cls is str:
+        reveal_type(cls)  # N: Revealed type is "def (o: builtins.object =) -> builtins.str"
+        reveal_type(cls(5))  # N: Revealed type is "builtins.str"
+
+    if issubclass(cls, int):
+        reveal_type(cls)  # N: Revealed type is "type[builtins.int]"
+    elif cls is str:
+        reveal_type(cls)  # N: Revealed type is "def (o: builtins.object =) -> builtins.str"
+        reveal_type(cls(5))  # N: Revealed type is "builtins.str"
+
+def f2(cls: type[object]):
+    if cls is str:
+        reveal_type(cls)  # N: Revealed type is "def (o: builtins.object =) -> builtins.str"
+        reveal_type(cls(5))  # N: Revealed type is "builtins.str"
+
+    if issubclass(cls, int):
+        reveal_type(cls)  # N: Revealed type is "type[builtins.int]"
+    elif cls is str:
+        reveal_type(cls)  # N: Revealed type is "def (o: builtins.object =) -> builtins.str"
+        reveal_type(cls(5))  # N: Revealed type is "builtins.str"
+
+def f3(cls: type[Any]):
+    if cls is str:
+        reveal_type(cls)  # N: Revealed type is "type[Any]"
+        reveal_type(cls(5))  # N: Revealed type is "Any"
+
+    if issubclass(cls, int):
+        reveal_type(cls)  # N: Revealed type is "type[builtins.int]"
+    elif cls is str:
+        reveal_type(cls)  # N: Revealed type is "type[Any]"
+        reveal_type(cls(5))  # N: Revealed type is "Any"
+[builtins fixtures/isinstance.pyi]
+
+[case testNarrowTypeObjectUnion]
+# flags: --strict-equality --warn-unreachable
+from __future__ import annotations
+
+def f4(cls: type[str | int]):
+    reveal_type(cls)  # N: Revealed type is "type[builtins.str] | type[builtins.int]"
+
+    if cls is int:
+        reveal_type(cls)  # N: Revealed type is "type[builtins.int]"
+    if cls == int:
+        reveal_type(cls)  # N: Revealed type is "type[builtins.int]"
+[builtins fixtures/primitives.pyi]
+
+
 [case testTypeEqualsCheck]
 # flags: --strict-equality --warn-unreachable
 from typing import Any
@@ -3261,3 +3315,23 @@ def bar(y: Any):
     else:
         reveal_type(y) # N: Revealed type is "Any"
 [builtins fixtures/dict-full.pyi]
+
+[case testNarrowTypeVarType]
+from typing import TypeVar
+
+T = TypeVar("T")
+
+class A: ...
+
+def foo(X: type[T]) -> T:
+    if X == A:
+        return X()
+    raise
+
+# It could be nice to make these two test cases consistent, but it would be tricky
+# The above case is much more common in real world code
+def bar(X: type[T]) -> T:
+    if X == A:
+        return A()  # E: Incompatible return value type (got "A", expected "T")
+    raise
+[builtins fixtures/type.pyi]

test-data/unit/fixtures/isinstance.pyi

@@ -22,6 +22,7 @@ class int:
 class float: pass
 class bool(int): pass
 class str:
+    def __new__(cls, o: object = ...) -> str: pass
     def __add__(self, other: 'str') -> 'str': pass
 class ellipsis: pass
 

test-data/unit/fixtures/type.pyi

@@ -10,6 +10,7 @@ S = TypeVar("S")
 class object:
     def __init__(self) -> None: pass
     def __str__(self) -> 'str': pass
+    def __eq__(self, value: object, /) -> bool: ...
 
 class list(Generic[T]): pass