fix: do not narrow expression type to TypeVar on equality comparison

When a variable is compared with == against a TypeVar operand, mypy was
narrowing its type to the TypeVar, causing false errors on subsequent
operations. The regression was introduced in #20602.

Skip narrowing in narrow_type_by_identity_equality when the target type
is a TypeVarLikeType. Fixes #21199

Author: ordinary9843

mypy/checker.py

@@ -6787,6 +6787,13 @@ def narrow_type_by_identity_equality(
                 ):
                     continue
 
+                # Do not narrow based on a TypeVar target: we don't know its concrete type,
+                # so narrowing e.g. `x: int` to `T` when comparing `x == y: T` is wrong.
+                # The narrowed TypeVar type is typically a supertype of the original, causing
+                # false errors on subsequent operations. See: github.com/python/mypy/issues/21199
+                if isinstance(get_proper_type(target_type), TypeVarLikeType):
+                    continue
+
                 target = TypeRange(target_type, is_upper_bound=False)
 
                 if_map, else_map = conditional_types_to_typemaps(

test-data/unit/check-narrowing.test

@@ -3993,3 +3993,33 @@ def f2(func: Callable[..., T], arg: str) -> T:
         return func(arg)
     return func(arg)
 [builtins fixtures/primitives.pyi]
+
+[case testNarrowingEqualityTypeVarTarget]
+# Regression test for https://github.com/python/mypy/issues/21199
+# When the RHS of == is a TypeVar, the LHS should not be narrowed to the TypeVar type.
+# flags: --python-version 3.10
+from typing import TypeVar
+
+T = TypeVar("T")
+
+def func_basic(x: int, y: T) -> None:
+    # x: int should remain int after comparing with TypeVar y; no error on x += 1
+    assert x == y
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+    x += 1
+
+def func_union(x: int | str, y: T) -> None:
+    # x: int | str should not be narrowed to T when compared with TypeVar
+    assert x == y
+    reveal_type(x)  # N: Revealed type is "builtins.int | builtins.str"
+
+def func_not_equal(x: int | str, y: T) -> None:
+    # != should also not over-narrow based on TypeVar
+    if x != y:
+        reveal_type(x)  # N: Revealed type is "builtins.int | builtins.str"
+
+def func_concrete_target(x: int | str, y: int) -> None:
+    # When the target is a concrete type (not TypeVar), narrowing is still allowed
+    if x == y:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/primitives.pyi]