Fallback

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -3180,21 +3180,51 @@ stringified(a=1)
 Only string-keyed mappings can be unpacked into named keyword parameters.
 
 ```py
-def takes_name(*, name: str) -> None: ...
+from typing_extensions import TypedDict, Unpack
+
+class HasNameKwargs(TypedDict):
+    name: str
+
+def takes_name_kwargs(**kwargs: Unpack[HasNameKwargs]) -> None: ...
 def _(int_key_dict: dict[int, str]) -> None:
     # snapshot: invalid-argument-type
-    takes_name(**int_key_dict)
+    takes_name_kwargs(**int_key_dict)
 ```
 
 ```snapshot
 error[invalid-argument-type]: Argument expression after ** must be a mapping with `str` key type
- --> src/mdtest_snippet.py:4:16
+ --> src/mdtest_snippet.py:9:23
   |
-4 |     takes_name(**int_key_dict)
-  |                ^^^^^^^^^^^^^^ Found `int`
+9 |     takes_name_kwargs(**int_key_dict)
+  |                       ^^^^^^^^^^^^^^ Found `int`
   |
 ```
 
+### Non-mapping values are rejected without missing-argument cascades
+
+```py
+from typing_extensions import TypedDict, Unpack
+
+class HasNameKwargs(TypedDict):
+    name: str
+
+class NotAMapping: ...
+
+def takes_name_kwargs(**kwargs: Unpack[HasNameKwargs]) -> None: ...
+def _(bad: NotAMapping) -> None:
+    # snapshot: invalid-argument-type
+    takes_name_kwargs(**bad)
+```
+
+```snapshot
+error[invalid-argument-type]: Argument expression after ** must be a mapping type
+  --> src/mdtest_snippet.py:11:25
+   |
+11 |     takes_name_kwargs(**bad)
+   |                         ^^^ Found `NotAMapping`
+   |
+```
+
 ### Explicit keywords still conflict with maybe-present unpacked keys
 
 If a partial `TypedDict` may provide a key, passing that key explicitly still counts as a duplicate.

crates/ty_python_semantic/src/types/call/bind.rs

@@ -4159,30 +4159,10 @@ impl<'a, 'db> ArgumentMatcher<'a, 'db> {
             return;
         }
 
-        if let Some((parameter_index, parameter)) = self.parameters.unpacked() {
-            let permissive_string_mapping = argument_type.is_some_and(|argument_type| {
-                let Some((key_ty, _value_ty)) = argument_type.unpack_keys_and_items(db) else {
-                    return false;
-                };
-
-                key_ty.is_assignable_to(db, KnownClass::Str.to_instance(db))
-            });
-
-            if !permissive_string_mapping {
-                self.errors.push(BindingError::InvalidArgumentType {
-                    parameter: ParameterContext {
-                        name: Some(parameter.display_name()),
-                        index: parameter_index,
-                        positional: false,
-                    },
-                    argument_index: self.get_argument_index(argument_index),
-                    expected_ty: parameter.annotated_type(),
-                    provided_ty: argument_type.unwrap_or_else(Type::unknown),
-                });
-                return;
-            }
-        }
-
+        // Fall back to ordinary `**kwargs` binding when the unpacked value is not TypedDict-shaped.
+        // This mirrors the non-`Unpack[TypedDict]` path: later validation still reports invalid
+        // `**` arguments, while binding here suppresses redundant missing-argument cascades and
+        // preserves per-parameter value checking for string-keyed mappings.
         for (parameter_index, parameter) in self.parameters.iter().enumerate() {
             if self.parameter_info[parameter_index]
                 .match_state

crates/ty_python_semantic/src/types/signatures.rs

@@ -2515,14 +2515,6 @@ impl<'db> Unpacked<'db> {
         }
     }
 
-    pub(crate) fn display_name(&self) -> Name {
-        Name::new(format!("**{}", self.name))
-    }
-
-    pub(crate) fn annotated_type(&self) -> Type<'db> {
-        self.annotated_type
-    }
-
     fn apply_type_mapping_impl<'a>(
         &self,
         db: &'db dyn Db,
@@ -3102,13 +3094,6 @@ impl<'db> Parameters<'db> {
             .enumerate()
             .rfind(|(_, parameter)| parameter.is_keyword_variadic())
     }
-
-    /// Return the retained `**kwargs: Unpack[TypedDict]` metadata and its index, if any.
-    pub(crate) fn unpacked(&self) -> Option<(usize, &Unpacked<'db>)> {
-        self.unpacked
-            .as_ref()
-            .map(|parameter| (self.value.len(), parameter))
-    }
 }
 
 impl<'db, 'a> IntoIterator for &'a Parameters<'db> {