Positional-only args

CHANGELOG.md

@@ -24,6 +24,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add commonly-used sequence methods to `PyList` and `PyTuple`. [#1849](https://github.com/PyO3/pyo3/pull/1849)
 - Add `as_sequence` methods to `PyList` and `PyTuple`. [#1860](https://github.com/PyO3/pyo3/pull/1860)
 - Add `abi3-py310` feature. [#1889](https://github.com/PyO3/pyo3/pull/1889)
+- Add support for positional-only arguments in `#[pyfunction]` [#1439](https://github.com/PyO3/pyo3/issues/1439)
 
 ### Changed
 

pyo3-macros-backend/src/method.rs

@@ -449,6 +449,17 @@ impl<'a> FnSpec<'a> {
         None
     }
 
+    pub fn is_pos_only(&self, name: &syn::Ident) -> bool {
+        for s in self.attrs.iter() {
+            if let Argument::PosOnlyArg(path, _) = s {
+                if path.is_ident(name) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
     pub fn is_kw_only(&self, name: &syn::Ident) -> bool {
         for s in self.attrs.iter() {
             if let Argument::Kwarg(path, _) = s {

pyo3-macros-backend/src/params.rs

@@ -78,6 +78,7 @@ pub fn impl_arg_params(
     };
 
     let mut positional_parameter_names = Vec::new();
+    let mut positional_only_parameters = 0usize;
     let mut required_positional_parameters = 0usize;
     let mut keyword_only_parameters = Vec::new();
 
@@ -86,6 +87,7 @@ pub fn impl_arg_params(
             continue;
         }
         let name = arg.name.unraw().to_string();
+        let posonly = spec.is_pos_only(arg.name);
         let kwonly = spec.is_kw_only(arg.name);
         let required = !(arg.optional.is_some() || spec.default_value(arg.name).is_some());
 
@@ -100,6 +102,9 @@ pub fn impl_arg_params(
             if required {
                 required_positional_parameters += 1;
             }
+            if posonly {
+                positional_only_parameters += 1;
+            }
             positional_parameter_names.push(name);
         }
     }
@@ -154,8 +159,7 @@ pub fn impl_arg_params(
                 cls_name: #cls_name,
                 func_name: stringify!(#python_name),
                 positional_parameter_names: &[#(#positional_parameter_names),*],
-                // TODO: https://github.com/PyO3/pyo3/issues/1439 - support specifying these
-                positional_only_parameters: 0,
+                positional_only_parameters: #positional_only_parameters,
                 required_positional_parameters: #required_positional_parameters,
                 keyword_only_parameters: &[#(#keyword_only_parameters),*],
                 accept_varargs: #accept_args,

pyo3-macros-backend/src/pyfunction.rs

@@ -22,9 +22,11 @@ use syn::{
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Argument {
+    PosOnlyArgsSeparator,
     VarArgsSeparator,
     VarArgs(syn::Path),
     KeywordArgs(syn::Path),
+    PosOnlyArg(syn::Path, Option<String>),
     Arg(syn::Path, Option<String>),
     Kwarg(syn::Path, Option<String>),
 }
@@ -34,6 +36,7 @@ pub enum Argument {
 pub struct PyFunctionSignature {
     pub arguments: Vec<Argument>,
     has_kw: bool,
+    has_posonly_args: bool,
     has_varargs: bool,
     has_kwargs: bool,
 }
@@ -126,7 +129,20 @@ impl PyFunctionSignature {
                 self.arguments.push(Argument::VarArgsSeparator);
                 Ok(())
             }
-            _ => bail_spanned!(item.span() => "expected \"*\""),
+            syn::Lit::Str(lits) if lits.value() == "/" => {
+                // "/"
+                self.posonly_arg_is_ok(item)?;
+                self.has_posonly_args = true;
+                // any arguments _before_ this become positional-only
+                self.arguments.iter_mut().for_each(|a| {
+                    if let Argument::Arg(path, name) = a {
+                        *a = Argument::PosOnlyArg(path.clone(), name.clone());
+                    }
+                });
+                self.arguments.push(Argument::PosOnlyArgsSeparator);
+                Ok(())
+            }
+            _ => bail_spanned!(item.span() => "expected \"/\" or \"*\""),
         }
     }
 
@@ -143,6 +159,14 @@ impl PyFunctionSignature {
         Ok(())
     }
 
+    fn posonly_arg_is_ok(&self, item: &NestedMeta) -> syn::Result<()> {
+        ensure_spanned!(
+            !(self.has_posonly_args || self.has_kwargs || self.has_varargs),
+            item.span() => "/ is not allowed after /, varargs(*), or kwargs(**)"
+        );
+        Ok(())
+    }
+
     fn vararg_is_ok(&self, item: &NestedMeta) -> syn::Result<()> {
         ensure_spanned!(
             !(self.has_kwargs || self.has_varargs),

tests/test_methods.rs

@@ -215,6 +215,36 @@ impl MethArgs {
         [a.to_object(py), args.into(), kwargs.to_object(py)].to_object(py)
     }
 
+    #[args(a, b, "/")]
+    fn get_posargs_only(&self, a: i32, b: i32) -> i32 {
+        a + b
+    }
+
+    #[args(a, "/", b)]
+    fn get_posargs_only_with_posargs(&self, a: i32, b: i32) -> i32 {
+        a + b
+    }
+
+    #[args(a, "/", b, c = 5)]
+    fn get_posargs_only_with_posargs_and_kwargs(&self, a: i32, b: i32, c: i32) -> i32 {
+        a + b + c
+    }
+
+    #[args(a, "/", b, "*", c, d = 5)]
+    fn get_all_arg_types_together(&self, a: i32, b: i32, c: i32, d: i32) -> i32 {
+        a + b + c + d
+    }
+
+    #[args(a, "/", "*", b)]
+    fn get_posargs_only_and_kwargs_only(&self, a: i32, b: i32) -> i32 {
+        a + b
+    }
+
+    #[args(a, "/", "*", b = 3)]
+    fn get_posargs_only_and_kwargs_only_with_defaults(&self, a: i32, b: i32) -> i32 {
+        a + b
+    }
+
     #[args("*", a = 2, b = 3)]
     fn get_kwargs_only_with_defaults(&self, a: i32, b: i32) -> i32 {
         a + b
@@ -308,6 +338,117 @@ fn meth_args() {
     py_expect_exception!(py, inst, "inst.get_pos_arg_kw(1, a=1)", PyTypeError);
     py_expect_exception!(py, inst, "inst.get_pos_arg_kw(b=2)", PyTypeError);
 
+    py_run!(py, inst, "assert inst.get_posargs_only(3, 5) == 8");
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only(a = 3, b = 5)",
+        PyTypeError
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only(3, b = 5)",
+        PyTypeError
+    );
+
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_with_posargs(1, 2) == 3"
+    );
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_with_posargs(1, b = 2) == 3"
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_with_posargs(a = 1, b = 2)",
+        PyTypeError
+    );
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_with_posargs_and_kwargs(1, 2) == 8"
+    );
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_with_posargs_and_kwargs(1, 2, c = 3) == 6"
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_with_posargs_and_kwargs(a = 1, b = 2)",
+        PyTypeError
+    );
+
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_all_arg_types_together(1, 2, c = 3, d = 3) == 9"
+    );
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_all_arg_types_together(1, 2, c = 3) == 11"
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_all_arg_types_together(a = 1, b = 2, d = 3)",
+        PyTypeError
+    );
+
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only(3, b = 5) == 8"
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only(3, 5)",
+        PyTypeError
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only(a = 3, b = 5)",
+        PyTypeError
+    );
+
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only_with_defaults(3) == 6"
+    );
+    py_run!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only_with_defaults(3, b = 5) == 8"
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only_with_defaults(3, 5)",
+        PyTypeError
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only_with_defaults(a = 3, b = 5)",
+        PyTypeError
+    );
+    py_expect_exception!(
+        py,
+        inst,
+        "assert inst.get_posargs_only_and_kwargs_only_with_defaults(a = 3)",
+        PyTypeError
+    );
+
     py_run!(py, inst, "assert inst.get_kwargs_only_with_defaults() == 5");
     py_run!(
         py,