From 42489e63d43740c600d5b53b5471a7fb407a6fa2 Mon Sep 17 00:00:00 2001
From: Colin Walters <walters@verbum.org>
Date: Fri, 4 Nov 2022 09:17:20 -0400
Subject: [PATCH] Move `g_cancellable_set_error_if_cancelled()` to manual

Regression from this change:
https://github.com/gtk-rs/gtk-rs-core/commit/7c9b36c270a945012a2f5d07c8d0f11912d66d34#diff-8439ea6875c9b60b7d07a7b39f6dde1d31d38459f7c27173e56b4cecb0eadefaR142

Basically `g_cancellable_set_error_if_cancelled()` doesn't follow the
GError conventions - it's the inverse, it returns `TRUE` if an error
was set, and `FALSE` otherwise.

We need to move this to manual implementation.

I caught this while updating ostree-rs-ext to use gio 0.15,
and our https://github.com/ostreedev/ostree-rs-ext/blob/main/lib/src/tokio_util.rs
unit test started to panic.
---
 gio/Gir.toml                       |  3 +++
 gio/src/auto/cancellable.rs        | 20 --------------------
 gio/src/cancellable.rs             | 29 +++++++++++++++++++++++++++++
 gio/src/subclass/async_initable.rs |  1 -
 4 files changed, 32 insertions(+), 21 deletions(-)

diff --git a/gio/Gir.toml b/gio/Gir.toml
index 2d1b433d8e54..6982eb7838ba 100644
--- a/gio/Gir.toml
+++ b/gio/Gir.toml
@@ -398,6 +398,9 @@ manual_traits = ["CancellableExtManual"]
     name = "cancelled"
     # Racy, use 'connect' and 'disconnect' instead
     ignore = true
+    [[object.function]]
+    name = "set_error_if_cancelled"
+    manual = true
 
 [[object]]
 name = "Gio.CharsetConverter"
diff --git a/gio/src/auto/cancellable.rs b/gio/src/auto/cancellable.rs
index 57d36e39b0e6..e260e6b43537 100644
--- a/gio/src/auto/cancellable.rs
+++ b/gio/src/auto/cancellable.rs
@@ -5,7 +5,6 @@
 use glib::object::IsA;
 use glib::translate::*;
 use std::fmt;
-use std::ptr;
 
 glib::wrapper! {
     #[doc(alias = "GCancellable")]
@@ -62,9 +61,6 @@ pub trait CancellableExt: 'static {
 
     #[doc(alias = "g_cancellable_release_fd")]
     fn release_fd(&self);
-
-    #[doc(alias = "g_cancellable_set_error_if_cancelled")]
-    fn set_error_if_cancelled(&self) -> Result<(), glib::Error>;
 }
 
 impl<O: IsA<Cancellable>> CancellableExt for O {
@@ -107,22 +103,6 @@ impl<O: IsA<Cancellable>> CancellableExt for O {
             ffi::g_cancellable_release_fd(self.as_ref().to_glib_none().0);
         }
     }
-
-    fn set_error_if_cancelled(&self) -> Result<(), glib::Error> {
-        unsafe {
-            let mut error = ptr::null_mut();
-            let is_ok = ffi::g_cancellable_set_error_if_cancelled(
-                self.as_ref().to_glib_none().0,
-                &mut error,
-            );
-            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
-            if error.is_null() {
-                Ok(())
-            } else {
-                Err(from_glib_full(error))
-            }
-        }
-    }
 }
 
 impl fmt::Display for Cancellable {
diff --git a/gio/src/cancellable.rs b/gio/src/cancellable.rs
index ceaacb770570..2c6c7a7a4ddc 100644
--- a/gio/src/cancellable.rs
+++ b/gio/src/cancellable.rs
@@ -75,6 +75,10 @@ pub trait CancellableExtManual {
     /// Returns a `Future` that completes when the cancellable becomes cancelled. Completes
     /// immediately if the cancellable is already cancelled.
     fn future(&self) -> std::pin::Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>;
+    // rustdoc-stripper-ignore-next
+    /// Set an error if the cancellable is already cancelled.
+    #[doc(alias = "g_cancellable_set_error_if_cancelled")]
+    fn set_error_if_cancelled(&self) -> Result<(), glib::Error>;
 }
 
 impl<O: IsA<Cancellable>> CancellableExtManual for O {
@@ -136,6 +140,24 @@ impl<O: IsA<Cancellable>> CancellableExtManual for O {
             }
         })
     }
+
+    fn set_error_if_cancelled(&self) -> Result<(), glib::Error> {
+        unsafe {
+            let mut error = std::ptr::null_mut();
+            let is_ok = ffi::g_cancellable_set_error_if_cancelled(
+                self.as_ref().to_glib_none().0,
+                &mut error,
+            );
+            // Here's the special case, this function has an inverted
+            // return value for the error case.
+            assert_eq!(is_ok == glib::ffi::GFALSE, error.is_null());
+            if error.is_null() {
+                Ok(())
+            } else {
+                Err(from_glib_full(error))
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -158,6 +180,13 @@ mod tests {
         c.disconnect_cancelled(id.unwrap());
     }
 
+    #[test]
+    fn cancellable_error_if_cancelled() {
+        let c = Cancellable::new();
+        c.cancel();
+        assert!(c.set_error_if_cancelled().is_err());
+    }
+
     #[test]
     fn cancellable_future() {
         let c = Cancellable::new();
diff --git a/gio/src/subclass/async_initable.rs b/gio/src/subclass/async_initable.rs
index 75c7b160fec6..b03095bd3743 100644
--- a/gio/src/subclass/async_initable.rs
+++ b/gio/src/subclass/async_initable.rs
@@ -9,7 +9,6 @@ use glib::subclass::prelude::*;
 
 use std::ptr;
 
-use crate::prelude::CancellableExt;
 use crate::prelude::CancellableExtManual;
 use crate::AsyncInitable;
 use crate::AsyncResult;