Method del

crates/stdlib/src/overlapped.rs:1525–1584

(zelf: &Py<Self>, vm: &VirtualMachine)

    impl Destructor for Overlapped {
        fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
            use windows_sys::Win32::Foundation::{
                ERROR_NOT_FOUND, ERROR_OPERATION_ABORTED, ERROR_SUCCESS,
            };
            use windows_sys::Win32::System::IO::{CancelIoEx, GetOverlappedResult};

            let mut inner = zelf.inner.lock();
            let olderr = unsafe { GetLastError() };

            // Cancel pending I/O and wait for completion
            if !HasOverlappedIoCompleted(&inner.overlapped)
                && !matches!(inner.data, OverlappedData::NotStarted)
            {
                let cancelled = unsafe { CancelIoEx(inner.handle, &inner.overlapped) } != 0;
                let mut transferred: u32 = 0;
                let ret = unsafe {
                    GetOverlappedResult(
                        inner.handle,
                        &inner.overlapped,
                        &mut transferred,
                        if cancelled { 1 } else { 0 },
                    )
                };

                let err = if ret != 0 {
                    ERROR_SUCCESS
                } else {
                    unsafe { GetLastError() }
                };
                match err {
                    ERROR_SUCCESS | ERROR_NOT_FOUND | ERROR_OPERATION_ABORTED => {}
                    _ => {
                        let msg = format!(
                            "{:?} still has pending operation at deallocation, the process may crash",
                            zelf
                        );
                        let exc = vm.new_runtime_error(msg);
                        let err_msg = Some(format!(
                            "Exception ignored while deallocating overlapped operation {:?}",
                            zelf
                        ));
                        let obj: PyObjectRef = zelf.to_owned().into();
                        vm.run_unraisable(exc, err_msg, obj);
                    }
                }
            }

            // Close the event handle
            if !inner.overlapped.hEvent.is_null() {
                unsafe {
                    Foundation::CloseHandle(inner.overlapped.hEvent);
                }
                inner.overlapped.hEvent = core::ptr::null_mut();
            }

            // Restore last error
            unsafe { Foundation::SetLastError(olderr) };