Reject arguments given by name and position in FuncArgs::bind_for

bind_for reports a keyword that fills a parameter already given by position before other binding errors, using the parameter list of the FromArgs type. getargs shares the message, str() drops its own check, and blake2b/blake2s name themselves in binding errors. Assisted-by: Claude Code:claude-opus-5-5
youknowone · Oct 7, 2026 · Oct 7, 2026 · Oct 7, 2026 · Oct 7, 2026 · Oct 7, 2026
commit 85846e569e9c3da6ebe663130c73e5f2d0177c01
diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py
@@ -275,7 +275,6 @@ def test_clinic_signature(self):
                     self._hashlib.new(digest_name, data=b'')
                     self._hashlib.new(digest_name, string=b'')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; duplicate positional/keyword arg error message differs
     @unittest.skipIf(get_fips_mode(), "skip in FIPS mode")
     def test_clinic_signature_errors(self):
         nomsg = b''

diff --git a/crates/stdlib/src/blake2.rs b/crates/stdlib/src/blake2.rs
@@ -149,7 +149,7 @@ mod _blake2 {
 
         #[pyslot]
         fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let args: BlakeHashArgs = args.bind(vm)?;
+            let args: BlakeHashArgs = args.bind_for(vm, "blake2b")?;
             Ok(Self {
                 inner: local_blake2b(args, vm)?,
             }
@@ -246,7 +246,7 @@ mod _blake2 {
 
         #[pyslot]
         fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let args: BlakeHashArgs = args.bind(vm)?;
+            let args: BlakeHashArgs = args.bind_for(vm, "blake2s")?;
             Ok(Self {
                 inner: local_blake2s(args, vm)?,
             }

diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
@@ -419,7 +419,7 @@ impl Constructor for PyStr {
 
     fn slot_new(cls: PyTypeRef, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         // A call with keyword arguments is parsed by unicode_new, which counts
-        // every argument and rejects one given both by name and by position.
+        // every argument.
         if !func_args.kwargs.is_empty() {
             let total = func_args.args.len() + func_args.kwargs.len();
             if total > 3 {
@@ -432,18 +432,6 @@ impl Constructor for PyStr {
                     "str() takes at most 3 {keyword}arguments ({total} given)"
                 )));
             }
-            for (i, name) in ["object", "encoding", "errors"]
-                .into_iter()
-                .enumerate()
-                .take(func_args.args.len())
-            {
-                if func_args.kwargs.contains_key(name) {
-                    return Err(vm.new_type_error(format!(
-                        "argument for str() given by name ('{name}') and position ({})",
-                        i + 1
-                    )));
-                }
-            }
         }
 
         // Optimization: return exact str as-is (only when no encoding/errors provided)

diff --git a/crates/vm/src/function/argument.rs b/crates/vm/src/function/argument.rs
@@ -1,4 +1,4 @@
-use super::signature::Param;
+use super::signature::{Param, ParamKind};
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{PyBaseExceptionRef, PyTupleRef, PyType},
@@ -307,6 +307,15 @@ impl FuncArgs {
         let arity = arity.start().saturating_sub(instance)..=arity.end().saturating_sub(instance);
         let num_given = self.args.len().saturating_sub(instance);
 
+        // A keyword that fills a parameter already given by position is
+        // reported before leftover-keyword and conversion errors.
+        if let Some(params) = T::PARAMS
+            && !self.kwargs.is_empty()
+            && let Some((name, pos)) = duplicate_name_and_position(params, num_given, &self.kwargs)
+        {
+            return Err(callee.given_by_name_and_position(name, pos, vm));
+        }
+
         let bound = T::from_args(vm, &mut self)
             .map_err(|e| e.into_exception(&arity, num_given, callee, vm))?;
 
@@ -408,6 +417,15 @@ impl Callee {
         vm.new_type_error(unexpected_keyword_message(self.name, keyword))
     }
 
+    fn given_by_name_and_position(
+        self,
+        keyword: &str,
+        pos: usize,
+        vm: &VirtualMachine,
+    ) -> PyBaseExceptionRef {
+        vm.new_type_error(given_by_name_and_position_message(self.name, keyword, pos))
+    }
+
     /// The branch of _PyArg_UnpackKeywords that names a parameter it didn't get.
     fn missing_argument(
         self,
@@ -464,6 +482,52 @@ pub(crate) fn unexpected_keyword_message(name: Option<&str>, keyword: &str) -> S
     format!("{name}{parens} got an unexpected keyword argument '{keyword}'")
 }
 
+pub(crate) fn given_by_name_and_position_message(
+    name: Option<&str>,
+    keyword: &str,
+    pos: usize,
+) -> String {
+    let name = name.map_or("function", short_name);
+    format!("argument for {name}() given by name ('{keyword}') and position ({pos})")
+}
+
+/// First positional-or-keyword parameter that was also passed by keyword.
+fn duplicate_name_and_position<'a>(
+    params: &'a [Param],
+    nargs: usize,
+    kwargs: &KwArgs,
+) -> Option<(&'a str, usize)> {
+    fn walk<'a>(
+        params: &'a [Param],
+        nargs: usize,
+        kwargs: &KwArgs,
+        pos: &mut usize,
+    ) -> Option<(&'a str, usize)> {
+        for param in params {
+            match param.kind {
+                ParamKind::Flatten(Some(inner)) => {
+                    if let Some(hit) = walk(inner, nargs, kwargs, pos) {
+                        return Some(hit);
+                    }
+                }
+                ParamKind::Flatten(None) | ParamKind::PositionalOnly => {
+                    *pos += 1;
+                }
+                ParamKind::PositionalOrKeyword => {
+                    *pos += 1;
+                    if nargs >= *pos && !param.name.is_empty() && kwargs.contains_key(param.name) {
+                        return Some((param.name, *pos));
+                    }
+                }
+                ParamKind::VarPositional => return None,
+                ParamKind::KeywordOnly | ParamKind::VarKeyword => {}
+            }
+        }
+        None
+    }
+    walk(params, nargs, kwargs, &mut 0)
+}
+
 /// The branch of _PyArg_UnpackKeywords that names a parameter it didn't get.
 pub(crate) fn missing_argument_message(name: Option<&str>, keyword: &str, pos: usize) -> String {
     let (name, parens) = call_form(name, "function");

diff --git a/crates/vm/src/function/getargs.rs b/crates/vm/src/function/getargs.rs
@@ -1,6 +1,6 @@
 //! `PyArg_ParseTupleAndKeywords` argument matching.
 
-use super::FuncArgs;
+use super::{FuncArgs, given_by_name_and_position_message};
 use crate::{PyObject, PyObjectRef, PyResult, VirtualMachine, common::wtf8::Wtf8};
 
 /// The keyword list of a `PyArg_ParseTupleAndKeywords` call together with the
@@ -103,9 +103,10 @@ impl ArgSpec<'_> {
         if !exhausted && nkwargs > 0 {
             for (i, name) in self.keywords.iter().enumerate().take(nargs) {
                 if args.kwargs.contains_key(name) {
-                    return Err(vm.new_type_error(format!(
-                        "argument for {fname}() given by name ('{name}') and position ({})",
-                        i + 1
+                    return Err(vm.new_type_error(given_by_name_and_position_message(
+                        Some(fname),
+                        name,
+                        i + 1,
                     )));
                 }
             }

diff --git a/crates/vm/src/function/mod.rs b/crates/vm/src/function/mod.rs
@@ -19,7 +19,9 @@ pub use argument::{
     NameKeywords, NameKwargs, NameKwds, NameKws, NameObjs, NameOthers, OptionalArg,
     OptionalArgDefault, OptionalOption, PosArgs, PositionalIterable,
 };
-pub(crate) use argument::{arity_message, unexpected_keyword_message};
+pub(crate) use argument::{
+    arity_message, given_by_name_and_position_message, unexpected_keyword_message,
+};
 pub use arithmetic::{PyArithmeticValue, PyComparisonValue};
 pub use buffer::{
     ArgAsciiBuffer, ArgBytesLike, ArgContiguousBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike,