Reject lack of **kwargs

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -3012,10 +3012,10 @@ func(v1=1, v2="optional", v3="ok")
 func(v1=1, v3="ok", v4=1)
 ```
 
-### Assignability to explicit keyword-only signatures
+### Assignability from unpacked kwargs to explicit keyword-only signatures
 
 A callable using `**kwargs: Unpack[TD2]` should line up with equivalent explicit keyword-only
-signatures, and the assignability should work in both directions.
+signatures when assigning to the explicit form.
 
 ```py
 from typing import Protocol
@@ -3041,12 +3041,12 @@ explicit_ok: ExplicitKwargs = func
 typed_dict_ok: TypedDictKwargs = func
 
 def _(explicit: ExplicitKwargs, typed_dict: TypedDictKwargs) -> None:
-    typed_dict_2: TypedDictKwargs = explicit
     explicit_2: ExplicitKwargs = typed_dict
 
 def func7(*, v1: int, v3: str, v2: str = "") -> None:
     pass
 
+# error: [invalid-assignment]
 typed_dict_from_explicit: TypedDictKwargs = func7
 ```
 

crates/ty_python_semantic/src/types/signatures.rs

@@ -709,7 +709,12 @@ impl<'db> Signature<'db> {
             parameters.next();
         }
 
-        let mut parameters = Parameters::new(db, parameters);
+        let mut parameters = Parameters::new(
+            db,
+            parameters
+                .chain(self.parameters.unpacked.iter().map(Unpacked::to_parameter))
+                .collect::<Vec<_>>(),
+        );
         let mut return_ty = self.return_ty;
         let binding_context = self.definition.map(BindingContext::Definition);
         if let Some(self_type) = self_type {
@@ -2321,6 +2326,17 @@ impl<'c, 'db> TypeRelationChecker<'_, 'c, 'db> {
             }
         }
 
+        // `**kwargs: Unpack[TypedDict]` must stay distinct from an equivalent explicit keyword-only
+        // surface. A target callable with unpacked kwargs can still be invoked with additional
+        // keyword arguments supplied through a TypedDict subtype, so a source callable needs a real
+        // `**kwargs` parameter as well.
+        if target.parameters.unpacked.is_some()
+            && source_keyword_variadic.is_none()
+            && source.parameters.unpacked.is_none()
+        {
+            return self.never();
+        }
+
         for target_param in target_keywords.into_iter().chain(target_params) {
             match target_param.kind() {
                 ParameterKind::KeywordOnly {
@@ -2516,6 +2532,19 @@ impl<'db> Unpacked<'db> {
             ),
         }
     }
+
+    fn to_parameter(&self) -> Parameter<'db> {
+        Parameter {
+            annotated_type: self.annotated_type,
+            inferred_annotation: false,
+            has_starred_annotation: false,
+            has_unpacked_kwargs_annotation: true,
+            kind: ParameterKind::KeywordVariadic {
+                name: self.name.clone(),
+            },
+            form: ParameterForm::Value,
+        }
+    }
 }
 
 impl<'db> Parameters<'db> {
@@ -2524,22 +2553,42 @@ impl<'db> Parameters<'db> {
     /// The kind of the parameter list is determined based on the provided parameters. Specifically,
     /// if the parameter list contains `*args` and `**kwargs`, then it checks their annotated types
     /// and the presence of other parameter kinds to determine if they represent a gradual form, a
-    /// `ParamSpec`, or a `Concatenate` form.
-    ///
-    /// Callers that need to retain `**kwargs: Unpack[TypedDict]` metadata separately from the
-    /// signature surface should use [`Self::from_value_and_unpacked`].
+    /// `ParamSpec`, or a `Concatenate` form. `**kwargs: Unpack[TypedDict]` is normalized here by
+    /// removing the original variadic keyword parameter from the signature surface, synthesizing
+    /// keyword-only parameters for the unpacked keys, and storing the original parameter
+    /// separately in [`Self::unpacked`].
     pub(crate) fn new(
         db: &'db dyn Db,
         parameters: impl IntoIterator<Item = Parameter<'db>>,
     ) -> Self {
-        Self::from_value_and_unpacked(db, parameters.into_iter().collect(), None)
-    }
+        let mut value: Vec<Parameter<'db>> = Vec::new();
+        let mut unpacked = None;
+
+        for parameter in parameters {
+            if let Some(unpacked_keys) = parameter.unpacked_typed_dict_keys(db) {
+                for (name, unpacked_key) in unpacked_keys {
+                    if value
+                        .iter()
+                        .any(|existing| existing.callable_by_name(name.as_str()))
+                    {
+                        continue;
+                    }
+
+                    value.push(
+                        Parameter::keyword_only(name)
+                            .with_annotated_type(unpacked_key.value_ty)
+                            .with_optional_default_type(
+                                (!unpacked_key.is_required).then_some(Type::unknown()),
+                            ),
+                    );
+                }
+
+                unpacked = Some(Unpacked::from_parameter(db, &parameter));
+            } else {
+                value.push(parameter);
+            }
+        }
 
-    pub(crate) fn from_value_and_unpacked(
-        db: &'db dyn Db,
-        value: Vec<Parameter<'db>>,
-        unpacked: Option<Unpacked<'db>>,
-    ) -> Self {
         debug_assert!(value.iter().all(|parameter| !parameter.is_unpacked(db)));
 
         let mut kind = ParametersKind::Standard;
@@ -2914,7 +2963,6 @@ impl<'db> Parameters<'db> {
             .chain(variadic)
             .chain(keyword_only)
             .collect::<Vec<_>>();
-        let mut unpacked = None;
 
         if let Some(arg) = kwarg.as_ref() {
             let keywords = Parameter::from_node_and_kind(
@@ -2925,31 +2973,10 @@ impl<'db> Parameters<'db> {
                     name: arg.name.id.clone(),
                 },
             );
-
-            if let Some(unpacked_keys) = keywords.unpacked_typed_dict_keys(db) {
-                for (name, unpacked_key) in unpacked_keys {
-                    if value
-                        .iter()
-                        .any(|parameter| parameter.callable_by_name(name.as_str()))
-                    {
-                        continue;
-                    }
-
-                    value.push(
-                        Parameter::keyword_only(name)
-                            .with_annotated_type(unpacked_key.value_ty)
-                            .with_optional_default_type(
-                                (!unpacked_key.is_required).then_some(Type::unknown()),
-                            ),
-                    );
-                }
-                unpacked = Some(Unpacked::from_parameter(db, &keywords));
-            } else {
-                value.push(keywords);
-            }
+            value.push(keywords);
         }
 
-        Self::from_value_and_unpacked(db, value, unpacked)
+        Self::new(db, value)
     }
 
     fn apply_type_mapping_impl<'a>(