Method remove_done_callback

crates/stdlib/src/_asyncio.rs:365–459

(&self, func: PyObjectRef, vm: &VirtualMachine)

        #[pymethod]
        fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
            if self.fut_loop.read().is_none() {
                return Err(vm.new_runtime_error("Future object is not initialized."));
            }
            let mut cleared_callback0 = 0usize;

            // Check fut_callback0 first
            // Clone to release lock before comparison (which may run Python code)
            let cb0 = self.fut_callback0.read().clone();
            if let Some(cb0) = cb0 {
                let cmp = vm.identical_or_equal(&cb0, &func)?;
                if cmp {
                    *self.fut_callback0.write() = None;
                    *self.fut_context0.write() = None;
                    cleared_callback0 = 1;
                }
            }

            // Check if fut_callbacks exists
            let callbacks = self.fut_callbacks.read().clone();
            let callbacks = match callbacks {
                Some(c) => c,
                None => return Ok(cleared_callback0),
            };

            let list: PyListRef = callbacks.downcast().unwrap();
            let len = list.borrow_vec().len();

            if len == 0 {
                *self.fut_callbacks.write() = None;
                return Ok(cleared_callback0);
            }

            // Special case for single callback
            if len == 1 {
                let item = list.borrow_vec().first().cloned();
                if let Some(item) = item {
                    let tuple: &PyTuple = item.downcast_ref().unwrap();
                    let cb = tuple.first().unwrap().clone();
                    let cmp = vm.identical_or_equal(&cb, &func)?;
                    if cmp {
                        *self.fut_callbacks.write() = None;
                        return Ok(1 + cleared_callback0);
                    }
                }
                return Ok(cleared_callback0);
            }

            // Multiple callbacks - iterate with index, checking validity each time
            // to handle evil comparisons
            let mut new_callbacks = Vec::with_capacity(len);
            let mut i = 0usize;
            let mut removed = 0usize;

            loop {
                // Re-check fut_callbacks on each iteration (evil code may have cleared it)
                let callbacks = self.fut_callbacks.read().clone();
                let callbacks = match callbacks {