Implement closed support in unpacking

Unpacking a TypedDict with an undeclared key to a TypedDict with that
key declared as not required is acceptable if the former is closed.
Unpacking an open TypedDict into a closed TypedDict is never safe.

Author: alicederyn

mypy/checkexpr.py

@@ -820,8 +820,8 @@ def validate_typeddict_kwargs(
         result = defaultdict(list)
         # Keys that are guaranteed to be present no matter what (e.g. for all items of a union)
         always_present_keys = set()
-        # Indicates latest encountered ** unpack among items.
-        last_star_found = None
+        # Indicates latest encountered ** unpack of a non-closed type among items.
+        last_open_star_found = None
 
         for item_name_expr, item_arg in kwargs:
             if item_name_expr:
@@ -845,22 +845,30 @@ def validate_typeddict_kwargs(
                     result[literal_value] = [item_arg]
                     always_present_keys.add(literal_value)
             else:
-                last_star_found = item_arg
-                if not self.validate_star_typeddict_item(
+                is_valid, is_open = self.validate_star_typeddict_item(
                     item_arg, callee, result, always_present_keys
-                ):
+                )
+                if not is_valid:
                     return None
-        if self.chk.options.extra_checks and last_star_found is not None:
+                if is_open:
+                    last_open_star_found = item_arg
+        if self.chk.options.extra_checks and last_open_star_found is not None:
+            if callee.is_closed:
+                self.chk.fail(
+                    "Cannot unpack item that may contain extra keys into a closed TypedDict",
+                    last_open_star_found,
+                    code=codes.TYPEDDICT_ITEM,
+                )
             absent_keys = []
             for key in callee.items:
                 if key not in callee.required_keys and key not in result:
                     absent_keys.append(key)
             if absent_keys:
-                # Having an optional key not explicitly declared by a ** unpacked
+                # Having an optional key not explicitly declared by a ** unpacked open
                 # TypedDict is unsafe, it may be an (incompatible) subtype at runtime.
                 # TODO: catch the cases where a declared key is overridden by a subsequent
                 # ** item without it (and not again overridden with complete ** item).
-                self.msg.non_required_keys_absent_with_star(absent_keys, last_star_found)
+                self.msg.non_required_keys_absent_with_star(absent_keys, last_open_star_found)
         return result, always_present_keys
 
     def validate_star_typeddict_item(
@@ -869,14 +877,18 @@ def validate_star_typeddict_item(
         callee: TypedDictType,
         result: dict[str, list[Expression]],
         always_present_keys: set[str],
-    ) -> bool:
+    ) -> tuple[bool, bool]:
         """Update keys/expressions from a ** expression in TypedDict constructor.
 
-        Note `result` and `always_present_keys` are updated in place. Return true if the
-        expression `item_arg` may valid in `callee` TypedDict context.
+        Note `result` and `always_present_keys` are updated in place.
+
+        First tuple item returned is true if the expression `item_arg` may valid
+        in `callee` TypedDict context. Second tuple item returned is true if the
+        expression may contain other keys not explicitly declared.
         """
         inferred = get_proper_type(self.accept(item_arg, type_context=callee))
-        possible_tds = []
+        any_fallback = False
+        possible_tds: list[TypedDictType] = []
         if isinstance(inferred, TypedDictType):
             possible_tds = [inferred]
         elif isinstance(inferred, UnionType):
@@ -885,10 +897,14 @@ def validate_star_typeddict_item(
                     possible_tds.append(item)
                 elif not self.valid_unpack_fallback_item(item):
                     self.msg.unsupported_target_for_star_typeddict(item, item_arg)
-                    return False
+                    return False, True
+                else:
+                    any_fallback = True
         elif not self.valid_unpack_fallback_item(inferred):
             self.msg.unsupported_target_for_star_typeddict(inferred, item_arg)
-            return False
+            return False, True
+        else:
+            any_fallback = True
         all_keys: set[str] = set()
         for td in possible_tds:
             all_keys |= td.items.keys()
@@ -917,7 +933,8 @@ def validate_star_typeddict_item(
                 # If this key is not required at least in some item of a union
                 # it may not shadow previous item, so we need to type check both.
                 result[key].append(arg)
-        return True
+        all_closed = all(t.is_closed for t in possible_tds)
+        return True, any_fallback or not all_closed
 
     def valid_unpack_fallback_item(self, typ: ProperType) -> bool:
         if isinstance(typ, AnyType):

test-data/unit/check-typeddict.test

@@ -5559,6 +5559,61 @@ def func(t: T):
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
+[case testTypedDictUnpackFromClosedMissingKey]
+# flags: --extra-checks
+from typing import TypedDict
+from typing_extensions import Never, NotRequired
+D1 = TypedDict("D1", {"a": int, "b": str}, closed=True)
+D2 = TypedDict("D2", {"a": int, "b": str, "c": int})
+D3 = TypedDict("D3", {"a": int, "b": str, "c": NotRequired[int]})
+d1: D1
+d2: D2 = {**d1}  # E: Missing key "c" for TypedDict "D2"
+d3: D3 = {**d1}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackIntoClosed]
+# flags: --extra-checks
+from typing import Any, Mapping, TypedDict, Union
+from typing_extensions import Never, NotRequired
+D1 = TypedDict("D1", {"a": int, "b": str}, closed=True)
+D2 = TypedDict("D2", {"a": int, "b": str})
+D3 = TypedDict("D3", {"c": int, "d": str}, closed=True)
+D4 = TypedDict("D4", {"c": int, "d": str})
+D5 = TypedDict("D5", {"a": int, "b": str, "c": int, "d": str}, closed=True)
+d1: D1
+d2: D2
+d3: D3
+d4: D4
+d5: D5
+m: Mapping[Any, Any]
+u34: Union[D3, D4]
+u35: Union[D3, D5]
+u5m: Union[D5, Mapping[Any, Any]]
+d5 = {**d1, **d3}
+d5 = {
+    **d1,
+    **d4,  # E: Cannot unpack item that may contain extra keys into a closed TypedDict
+}
+d5 = {
+    **d2,  # E: Cannot unpack item that may contain extra keys into a closed TypedDict
+    **d3,
+}
+d5 = {
+    **d1,
+    **u34,  # E: Cannot unpack item that may contain extra keys into a closed TypedDict
+}
+d5 = {**d1, **u35}
+d5 = {
+    **m,  # E: Cannot unpack item that may contain extra keys into a closed TypedDict
+    **d5,
+}
+d5 = {
+    **u5m,  # E: Cannot unpack item that may contain extra keys into a closed TypedDict
+}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
 
 [case testTypedDictFinalAndClassVar]
 from typing import TypedDict, Final, ClassVar