Borrowed constructor argument can outlive its owner

use std::cell::RefCell;
use pyo3::prelude::*;
use pyo3::ffi;
use pyo3::types::{PyDict, PyTuple};

struct Ignored;

impl<'a, 'py> FromPyObject<'a, 'py> for Ignored {
    type Error = PyErr;

    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
        let _ = obj.get_type();
        println!("second conversion reached");
        Ok(Self)
    }
}

#[pyclass]
struct Victim;

impl Drop for Victim {
    fn drop(&mut self) { println!("Victim::drop: second finalized"); }
}

#[pyclass(unsendable)]
struct Index { kwargs: RefCell<Option<Py<PyDict>>> }

#[pymethods]
impl Index {
    fn __index__(&self, py: Python<'_>) -> PyResult<i64> {
        println!("Index::__index__: deleting kwargs['second']");
        let kwargs = self.kwargs.borrow_mut().take().unwrap();
        let victim_ptr = {
            let victim = kwargs.bind(py).get_item("second")?.unwrap();
            victim.as_ptr()
        };
        println!("Victim refcount before deletion: {}", unsafe {
            ffi::Py_REFCNT(victim_ptr)
        });
        kwargs.bind(py).del_item("second")?;
        println!("Victim refcount after deletion: {}", unsafe {
            ffi::Py_REFCNT(victim_ptr)
        });
        Ok(7)
    }
}

#[pyclass]
struct C;

#[pymethods]
impl C {
    #[new]
    fn new(first: i64, second: Ignored) -> Self {
        let _ = (first, second);
        println!("constructor reached");
        C
    }
}

fn main() -> PyResult<()> {
    Python::attach(|py| {
        let kwargs = PyDict::new(py);
        let index = Py::new(py, Index {
            kwargs: RefCell::new(Some(kwargs.clone().unbind())),
        })?;
        kwargs.set_item("first", index)?;
        kwargs.set_item("second", Py::new(py, Victim)?)?;
        let _ = py.get_type::<C>().call(PyTuple::empty(py), Some(&kwargs))?;
        Ok(())
    })
}

Index::__index__: deleting kwargs['second']
Victim refcount before deletion: 1
Victim::drop: second finalized
Victim refcount after deletion: 0
second conversion reached
constructor reached