[DNM] Disallow optional arguments after positional arguments

[juniperparsnips]

When a rust binding has an optional parameter followed by a required parameter it may cause a hard to follow panic in python.
To reproduce:

use pyo3::prelude::*;

#[pyclass]
struct Foo {
    #[pyo3(get, set)]
    pub a: i32
}

#[pymethods]
impl Foo {
    #[new]
    fn new() -> Self {
        Self { a: 0 }
    }

    fn opt_first(&mut self, a: Option<i32>, b: i32) {
        self.a = a.unwrap_or(b)
    }
}

#[pymodule]
fn pyo3test(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_class::<Foo>()?;
    Ok(())
}

>>> import pyo3test
>>> foo = pyo3test.Foo()
>>> foo.opt_first()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Foo.opt_first() missing 1 required positional argument: 'a'
>>> foo.opt_first(1)
thread '<unnamed>' panicked at 'Failed to extract required method argument', src/lib.rs:24:48
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
pyo3_runtime.PanicException: Failed to extract required method argument
>>> foo.opt_first(1, 2)
>>> foo.a
1
>>>

While the python type hinting states that there is only one required positional argument, the function behaves as if there are two required arguments, and even if one were optional, it would be 'a', not 'b'. Additionally, this behavior leads to illegal python, as def opt_first(a: Optional[int]=None, b: int) triggers the "non-default argument follows default argument" syntax error.

Reworking the proc-macro so that an Option followed by a required positional parameter must be provided would make the behavior of Options inconsistent, so we should explicitly disallow required parameters that follow optional parameters.

Both of the following now fail at compile time rather than runtime,

#[pymethods]
impl Foo {
    fn opt_first(&mut self, a: Option<i32>, b: i32) {
        self.a = a.unwrap_or(b)
    }

    #[args(a = "1")]
    fn default_first_provided(&mut self, a: i32, b: i32) {
        self.a = a + b;
    }
}

While these still compile and work as expected,

#[pymethods]
impl Foo {
    #[args(b = "5")]
    fn default_last_provided(&mut self, a: Option<i32>, b: i32) {
        self.a = a.unwrap_or(b)
    }

    fn opt_last(&mut self, a:i32, b: Option<i32>) {
        self.a = b.unwrap_or(a)
    }
}

[Property404]

Excellent work

[Property404]

nit: looks like the other error messages use "cannot"

[Property404]

Wait - we can do foo.opt_first(None, 1), right? That's what was done in the example you changed

[juniperparsnips]

Wait - we can do foo.opt_first(None, 1), right? That's what was done in the example you changed

Before these changes, yes:

>>> import pyo3test
>>> foo = pyo3test.Foo()
>>> foo.opt_first(None, 1)
>>> foo.a
1

[juniperparsnips]

• "can't" => "cannot"

[juniperparsnips]

Merge to starry/0.15.1 instead.