gh-20512: Fix specialization leak in generic TypedDict.update() (#20517)

Fixes gh-20512

This PR fixes a bug where calling .update() on a specialized generic
TypedDict like Group[int] would fail type checking because the plugin
reverted to the unspecialized definition (Group[ValT]).

After a lot of dead ends this one wasn't as straightforward as I thought
initially. After spending a lot of time in `checkmember.py` and
`checkexpr.py`I finally found the issue in `mypy/plugins/default.py`.
The call got the anonymous version of the TypedDict from the TypeInfo,
which pointed back to the original generic declaration. This caused
specialized types to be replaced by their original TypeVar placeholders
during the signature construction for update(). Whew!

The fix basically uses `ctx.type` (the specialized type of TypedDict
being updated) as the source for the items, then applies the anonymous
fallback and sets `required_keys` to an empty set to keep the correct
behavior of the update method.

Added a test in `check-typeddict.test` which seemed like the right
place. All tests pass, as well as the original repro script from the
linked issue.

---------

Co-authored-by: Aaron Wieczorek <woz@Aarons-MacBook-Pro.local>
Co-authored-by: hauntsaninja <hauntsaninja@gmail.com>

Author: 3 people

mypy/constraints.py

@@ -816,7 +816,7 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
         if isinstance(actual, Overloaded) and actual.fallback is not None:
             actual = actual.fallback
         if isinstance(actual, TypedDictType):
-            actual = actual.as_anonymous().fallback
+            actual = actual.create_anonymous_fallback()
         if isinstance(actual, LiteralType):
             actual = actual.fallback
         if isinstance(actual, Instance):

mypy/meet.py

@@ -1263,7 +1263,7 @@ def typed_dict_mapping_overlap(
     key_type, value_type = get_proper_types(other.args)
 
     # TODO: is there a cleaner way to get str_type here?
-    fallback = typed.as_anonymous().fallback
+    fallback = typed.create_anonymous_fallback()
     str_type = fallback.type.bases[0].args[0]  # typing._TypedDict inherits Mapping[str, object]
 
     # Special case: a TypedDict with no required keys overlaps with an empty dict.

mypy/plugins/default.py

@@ -479,8 +479,9 @@ def typed_dict_update_signature_callback(ctx: MethodSigContext) -> CallableType:
         arg_type = get_proper_type(signature.arg_types[0])
         if not isinstance(arg_type, TypedDictType):
             return signature
-        arg_type = arg_type.as_anonymous()
-        arg_type = arg_type.copy_modified(required_keys=set())
+        arg_type = ctx.type.copy_modified(
+            fallback=arg_type.create_anonymous_fallback(), required_keys=set()
+        )
         if ctx.args and ctx.args[0]:
             if signature.name in _TP_DICT_MUTATING_METHODS:
                 # If we want to mutate this object in place, we need to set this flag,

mypy/types.py

@@ -3080,11 +3080,11 @@ def is_final(self) -> bool:
     def is_anonymous(self) -> bool:
         return self.fallback.type.fullname in TPDICT_FB_NAMES
 
-    def as_anonymous(self) -> TypedDictType:
+    def create_anonymous_fallback(self) -> Instance:
         if self.is_anonymous():
-            return self
+            return self.fallback
         assert self.fallback.type.typeddict_type is not None
-        return self.fallback.type.typeddict_type.as_anonymous()
+        return self.fallback.type.typeddict_type.create_anonymous_fallback()
 
     def copy_modified(
         self,
@@ -3110,10 +3110,6 @@ def copy_modified(
             required_keys &= set(item_names)
         return TypedDictType(items, required_keys, readonly_keys, fallback, self.line, self.column)
 
-    def create_anonymous_fallback(self) -> Instance:
-        anonymous = self.as_anonymous()
-        return anonymous.fallback
-
     def names_are_wider_than(self, other: TypedDictType) -> bool:
         return len(other.items.keys() - self.items.keys()) == 0
 

test-data/unit/check-typeddict.test

@@ -3011,6 +3011,39 @@ reveal_type(s3)  # N: Revealed type is "TypedDict('__main__.Sub3', {'x': Any, 'y
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
+[case testGenericTypedDictUpdate]
+from typing import TypedDict, Generic, TypeVar
+
+T = TypeVar("T")
+
+class Group(TypedDict, Generic[T]):
+    a: T
+
+value: Group[int] = {"a": 1}
+
+def func(value2: Group[int]) -> None:
+    value.update(value2)
+    value.update({"a": 2})
+    value.update({"a": "string"})  # E: Incompatible types (expression has type "str", TypedDict item "a" has type "int")
+
+S = TypeVar("S")
+
+class MultiField(TypedDict, Generic[T, S]):
+    x: T
+    y: S
+
+mf1: MultiField[int, str] = {"x": 1, "y": "a"}
+mf2: MultiField[int, str] = {"x": 2, "y": "b"}
+mf1.update(mf2)
+
+mf3: MultiField[str, str] = {"x": "test", "y": "c"}
+mf1.update(mf3)  # E: Argument 1 to "update" of "TypedDict" has incompatible type "MultiField[str, str]"; expected "TypedDict({'x': int, 'y': str})"
+
+mf1.update({"x": 3})
+mf1.update({"y": "d"})
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
 [case testTypedDictAttributeOnClassObject]
 from typing import TypedDict