Make clippy happy with code emitted by impl_arg_param

[mejrs]

Fixes some bad error message when Rust can't find a type:

// missing PathBuf import
use pyo3::prelude::*;

#[pyclass]
pub struct S;

#[pymethods]
impl S {
    #[new]
    #[args(path = "None")]
    fn new(path: Option<PathBuf>) -> PyResult<Self> {
        todo!()
    }
}

-- snip --

error[E0282]: type annotations needed for `Option<T>`
 --> src\lib.rs:7:1
  |
7 | #[pymethods]
  | ^^^^^^^^^^^^ consider giving `arg0` the explicit type `Option<T>`, where the type parameter `T` is specified
  |
  = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)

Some errors have detailed explanations: E0282, E0412.
For more information about an error, try `rustc --explain E0282`.

Fixes rust-lang/rust-clippy#8971

#[pyo3::pyfunction]
pub fn hash_djb2(_s: &str) -> i32 {
    0
}

warning: deref on an immutable reference
 --> src\lib.rs:3:22
  |
3 | pub fn hash_djb2(_s: &str) -> i32 {
  |                      ^^^^ help: if you would like to reborrow, try removing `&*`: `&str`
  |
  = note: `#[warn(clippy::borrow_deref_ref)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref

warning: `my_module` (lib) generated 1 warning

[davidhewitt]

This might need a call to remove_lifetime. Can you add a test for a pyfunction with something like Vec<&'py PyAny> as an argument? I've also been wondering if it's possible for us to copy lifetimes from the function definition onto the generated pyfunction - I think that might also solve the problem but not sure.

[davidhewitt]

Lack of remove_lifetime is probably why pyproto broke - it inserts a hidden lifetime to try and behave like lifetime elision :(. Super weird and so close to killing off now!

[davidhewitt]

Thanks! I've paused on reviewing this one for a bit just because I've always viewed the deref juggling the macro does here as a bit janky. I finally had an idea how to introduce a PyFunctionArgument trait which should allow the macros to do less (relying on type inference instead).

I haven't quite finished off that branch, I'm hoping I'll get a chance to implement at the weekend and see what folks think.

[davidhewitt]

Closing as superseded by #2503