Implement TypeVar support in narrowing

If a TypeVar with a TypedDict upper bound is encountered while
narrowing, narrow based on the upper bound.

Author: alicederyn

mypy/checker.py

@@ -6391,7 +6391,8 @@ def conditional_types_for_iterable(
     ) -> tuple[Type, Type]:
         """
         Narrows the type of `iterable_type` based on the type of `item_type`.
-        For now, we only support narrowing unions of TypedDicts based on left operand being literal string(s).
+        For now, we only support narrowing unions of TypedDicts, and TypeVars with TypedDict
+        bounds, based on left operand being literal string(s).
         """
         if_types: list[Type] = []
         else_types: list[Type] = []
@@ -6405,18 +6406,19 @@ def conditional_types_for_iterable(
         item_str_literals = try_getting_str_literals_from_type(item_type)
 
         for possible_iterable_type in possible_iterable_types:
-            if item_str_literals and isinstance(possible_iterable_type, TypedDictType):
+            bound = (
+                get_proper_type(possible_iterable_type.upper_bound)
+                if isinstance(possible_iterable_type, TypeVarType)
+                else possible_iterable_type
+            )
+
+            if item_str_literals and isinstance(bound, TypedDictType):
                 for key in item_str_literals:
-                    if key in possible_iterable_type.required_keys:
+                    if key in bound.required_keys:
                         if_types.append(possible_iterable_type)
                     elif (
-                        key in possible_iterable_type.items
-                        and not isinstance(possible_iterable_type.items[key], UninhabitedType)
-                    ) or (
-                        key not in possible_iterable_type.items
-                        and not possible_iterable_type.is_closed
-                        and not possible_iterable_type.is_final
-                    ):
+                        key in bound.items and not isinstance(bound.items[key], UninhabitedType)
+                    ) or (key not in bound.items and not bound.is_closed and not bound.is_final):
                         if_types.append(possible_iterable_type)
                         else_types.append(possible_iterable_type)
                     else:

test-data/unit/check-typeddict.test

@@ -5527,6 +5527,21 @@ else:
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-full.pyi]
 
+[case testOperatorContainsNarrowsTypeVarWithClosedTypedDictBound]
+from typing import TypedDict, TypeVar
+from typing_extensions import Never, assert_type
+
+T = TypeVar('T', bound='D')
+
+class D(TypedDict, closed=True):
+    a: int
+
+def func(t: T):
+    if "b" in t:
+        assert_type(t, Never)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
 
 [case testTypedDictFinalAndClassVar]
 from typing import TypedDict, Final, ClassVar