Rust 2024 edition preparations: Run cargo fix --edition

gdk4/src/cairo_interaction.rs

@@ -44,18 +44,20 @@ pub trait GdkCairoContextExt: sealed::Sealed {
         width: i32,
         height: i32,
     ) {
-        skip_assert_initialized!();
-        ffi::gdk_cairo_draw_from_gl(
-            self.to_raw(),
-            surface.to_glib_none().0,
-            source,
-            source_type,
-            buffer_scale,
-            x,
-            y,
-            width,
-            height,
-        );
+        unsafe {
+            skip_assert_initialized!();
+            ffi::gdk_cairo_draw_from_gl(
+                self.to_raw(),
+                surface.to_glib_none().0,
+                source,
+                source_type,
+                buffer_scale,
+                x,
+                y,
+                width,
+                height,
+            );
+        }
     }
 
     #[doc(alias = "gdk_cairo_set_source_rgba")]

gdk4/src/clipboard.rs

@@ -34,23 +34,25 @@ impl Clipboard {
             res: *mut gio::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
         ) {
-            let mut error = ptr::null_mut();
-            let mut out_mime_type = ptr::null();
-            let ret = ffi::gdk_clipboard_read_finish(
-                _source_object as *mut _,
-                res,
-                &mut out_mime_type,
-                &mut error,
-            );
-            let result = if error.is_null() {
-                Ok((from_glib_full(ret), from_glib_none(out_mime_type)))
-            } else {
-                Err(from_glib_full(error))
-            };
-            let callback: Box<glib::thread_guard::ThreadGuard<Q>> =
-                Box::from_raw(user_data as *mut _);
-            let callback = callback.into_inner();
-            callback(result);
+            unsafe {
+                let mut error = ptr::null_mut();
+                let mut out_mime_type = ptr::null();
+                let ret = ffi::gdk_clipboard_read_finish(
+                    _source_object as *mut _,
+                    res,
+                    &mut out_mime_type,
+                    &mut error,
+                );
+                let result = if error.is_null() {
+                    Ok((from_glib_full(ret), from_glib_none(out_mime_type)))
+                } else {
+                    Err(from_glib_full(error))
+                };
+                let callback: Box<glib::thread_guard::ThreadGuard<Q>> =
+                    Box::from_raw(user_data as *mut _);
+                let callback = callback.into_inner();
+                callback(result);
+            }
         }
         let callback = read_async_trampoline::<Q>;
         unsafe {

gdk4/src/drop.rs

@@ -34,23 +34,25 @@ impl Drop {
             res: *mut gio::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
         ) {
-            let mut error = ptr::null_mut();
-            let mut out_mime_type = ptr::null();
-            let ret = ffi::gdk_drop_read_finish(
-                _source_object as *mut _,
-                res,
-                &mut out_mime_type,
-                &mut error,
-            );
-            let result = if error.is_null() {
-                Ok((from_glib_full(ret), from_glib_none(out_mime_type)))
-            } else {
-                Err(from_glib_full(error))
-            };
-            let callback: Box<glib::thread_guard::ThreadGuard<Q>> =
-                Box::from_raw(user_data as *mut _);
-            let callback = callback.into_inner();
-            callback(result);
+            unsafe {
+                let mut error = ptr::null_mut();
+                let mut out_mime_type = ptr::null();
+                let ret = ffi::gdk_drop_read_finish(
+                    _source_object as *mut _,
+                    res,
+                    &mut out_mime_type,
+                    &mut error,
+                );
+                let result = if error.is_null() {
+                    Ok((from_glib_full(ret), from_glib_none(out_mime_type)))
+                } else {
+                    Err(from_glib_full(error))
+                };
+                let callback: Box<glib::thread_guard::ThreadGuard<Q>> =
+                    Box::from_raw(user_data as *mut _);
+                let callback = callback.into_inner();
+                callback(result);
+            }
         }
         let callback = read_async_trampoline::<Q>;
         unsafe {

gdk4/src/event.rs

@@ -167,7 +167,7 @@ macro_rules! define_event {
         impl glib::translate::FromGlibPtrFull<*mut crate::ffi::GdkEvent> for $rust_type {
             #[inline]
             unsafe fn from_glib_full(ptr: *mut crate::ffi::GdkEvent) -> Self {
-                glib::translate::FromGlibPtrFull::from_glib_full(ptr as *mut $ffi_type)
+                unsafe { glib::translate::FromGlibPtrFull::from_glib_full(ptr as *mut $ffi_type) }
             }
         }
 

gdk4/src/functions.rs

@@ -60,17 +60,21 @@ pub fn content_deserialize_async<R: FnOnce(Result<glib::Value, glib::Error>) + '
         res: *mut gio::ffi::GAsyncResult,
         user_data: glib::ffi::gpointer,
     ) {
-        let mut error = ptr::null_mut();
-        let mut value = glib::Value::uninitialized();
-        let _ = ffi::gdk_content_deserialize_finish(res, value.to_glib_none_mut().0, &mut error);
-        let result = if error.is_null() {
-            Ok(value)
-        } else {
-            Err(from_glib_full(error))
-        };
-        let callback: Box<glib::thread_guard::ThreadGuard<R>> = Box::from_raw(user_data as *mut _);
-        let callback = callback.into_inner();
-        callback(result);
+        unsafe {
+            let mut error = ptr::null_mut();
+            let mut value = glib::Value::uninitialized();
+            let _ =
+                ffi::gdk_content_deserialize_finish(res, value.to_glib_none_mut().0, &mut error);
+            let result = if error.is_null() {
+                Ok(value)
+            } else {
+                Err(from_glib_full(error))
+            };
+            let callback: Box<glib::thread_guard::ThreadGuard<R>> =
+                Box::from_raw(user_data as *mut _);
+            let callback = callback.into_inner();
+            callback(result);
+        }
     }
     let callback = content_deserialize_async_trampoline::<R>;
     unsafe {
@@ -127,26 +131,31 @@ pub fn content_register_deserializer<
     >(
         deserializer: *mut ffi::GdkContentDeserializer,
     ) {
-        let deserializer: ContentDeserializer = from_glib_full(deserializer);
-        let callback: &P =
-            &*(ffi::gdk_content_deserializer_get_user_data(deserializer.to_glib_none().0)
-                as *mut _);
+        unsafe {
+            let deserializer: ContentDeserializer = from_glib_full(deserializer);
+            let callback: &P =
+                &*(ffi::gdk_content_deserializer_get_user_data(deserializer.to_glib_none().0)
+                    as *mut _);
 
-        let mut task_data: *mut Option<T> =
-            ffi::gdk_content_deserializer_get_task_data(deserializer.to_glib_none().0) as *mut _;
-        if task_data.is_null() {
-            unsafe extern "C" fn notify_func<T: 'static>(data: glib::ffi::gpointer) {
-                let _task_data: Box<Option<T>> = Box::from_raw(data as *mut _);
+            let mut task_data: *mut Option<T> =
+                ffi::gdk_content_deserializer_get_task_data(deserializer.to_glib_none().0)
+                    as *mut _;
+            if task_data.is_null() {
+                unsafe extern "C" fn notify_func<T: 'static>(data: glib::ffi::gpointer) {
+                    unsafe {
+                        let _task_data: Box<Option<T>> = Box::from_raw(data as *mut _);
+                    }
+                }
+                task_data = Box::into_raw(Box::new(None));
+                ffi::gdk_content_deserializer_set_task_data(
+                    deserializer.to_glib_none().0,
+                    task_data as *mut _,
+                    Some(notify_func::<T>),
+                );
             }
-            task_data = Box::into_raw(Box::new(None));
-            ffi::gdk_content_deserializer_set_task_data(
-                deserializer.to_glib_none().0,
-                task_data as *mut _,
-                Some(notify_func::<T>),
-            );
-        }
 
-        (*callback)(&deserializer, &mut *task_data);
+            (*callback)(&deserializer, &mut *task_data);
+        }
     }
     let deserialize = Some(deserialize_func::<T, P> as _);
     unsafe extern "C" fn notify_func<
@@ -155,7 +164,9 @@ pub fn content_register_deserializer<
     >(
         data: glib::ffi::gpointer,
     ) {
-        let _callback: Box<P> = Box::from_raw(data as *mut _);
+        unsafe {
+            let _callback: Box<P> = Box::from_raw(data as *mut _);
+        }
     }
     let destroy_call4 = Some(notify_func::<T, P> as _);
     let super_callback0: Box<P> = deserialize_data;
@@ -187,25 +198,30 @@ pub fn content_register_serializer<
     >(
         serializer: *mut ffi::GdkContentSerializer,
     ) {
-        let serializer: ContentSerializer = from_glib_full(serializer);
-        let callback: &P =
-            &*(ffi::gdk_content_serializer_get_user_data(serializer.to_glib_none().0) as *mut _);
+        unsafe {
+            let serializer: ContentSerializer = from_glib_full(serializer);
+            let callback: &P =
+                &*(ffi::gdk_content_serializer_get_user_data(serializer.to_glib_none().0)
+                    as *mut _);
 
-        let mut task_data: *mut Option<T> =
-            ffi::gdk_content_serializer_get_task_data(serializer.to_glib_none().0) as *mut _;
-        if task_data.is_null() {
-            unsafe extern "C" fn notify_func<T: 'static>(data: glib::ffi::gpointer) {
-                let _task_data: Box<Option<T>> = Box::from_raw(data as *mut _);
+            let mut task_data: *mut Option<T> =
+                ffi::gdk_content_serializer_get_task_data(serializer.to_glib_none().0) as *mut _;
+            if task_data.is_null() {
+                unsafe extern "C" fn notify_func<T: 'static>(data: glib::ffi::gpointer) {
+                    unsafe {
+                        let _task_data: Box<Option<T>> = Box::from_raw(data as *mut _);
+                    }
+                }
+                task_data = Box::into_raw(Box::new(None));
+                ffi::gdk_content_serializer_set_task_data(
+                    serializer.to_glib_none().0,
+                    task_data as *mut _,
+                    Some(notify_func::<T>),
+                );
             }
-            task_data = Box::into_raw(Box::new(None));
-            ffi::gdk_content_serializer_set_task_data(
-                serializer.to_glib_none().0,
-                task_data as *mut _,
-                Some(notify_func::<T>),
-            );
-        }
 
-        (*callback)(&serializer, &mut *task_data);
+            (*callback)(&serializer, &mut *task_data);
+        }
     }
     let serialize = Some(serialize_func::<T, P> as _);
     unsafe extern "C" fn notify_func<
@@ -214,7 +230,9 @@ pub fn content_register_serializer<
     >(
         data: glib::ffi::gpointer,
     ) {
-        let _callback: Box<P> = Box::from_raw(data as *mut _);
+        unsafe {
+            let _callback: Box<P> = Box::from_raw(data as *mut _);
+        }
     }
     let destroy_call4 = Some(notify_func::<T, P> as _);
     let super_callback0: Box<P> = serialize_data;
@@ -257,16 +275,19 @@ pub fn content_serialize_async<R: FnOnce(Result<(), glib::Error>) + 'static>(
         res: *mut gio::ffi::GAsyncResult,
         user_data: glib::ffi::gpointer,
     ) {
-        let mut error = ptr::null_mut();
-        let _ = ffi::gdk_content_serialize_finish(res, &mut error);
-        let result = if error.is_null() {
-            Ok(())
-        } else {
-            Err(from_glib_full(error))
-        };
-        let callback: Box<glib::thread_guard::ThreadGuard<R>> = Box::from_raw(user_data as *mut _);
-        let callback = callback.into_inner();
-        callback(result);
+        unsafe {
+            let mut error = ptr::null_mut();
+            let _ = ffi::gdk_content_serialize_finish(res, &mut error);
+            let result = if error.is_null() {
+                Ok(())
+            } else {
+                Err(from_glib_full(error))
+            };
+            let callback: Box<glib::thread_guard::ThreadGuard<R>> =
+                Box::from_raw(user_data as *mut _);
+            let callback = callback.into_inner();
+            callback(result);
+        }
     }
     let callback = content_serialize_async_trampoline::<R>;
     unsafe {

gdk4/src/gl_texture.rs

@@ -11,14 +11,16 @@ impl GLTexture {
     #[doc(alias = "gdk_gl_texture_new")]
     #[allow(clippy::missing_safety_doc)]
     pub unsafe fn new(context: &GLContext, id: u32, width: i32, height: i32) -> Self {
-        from_glib_full(ffi::gdk_gl_texture_new(
-            context.to_glib_none().0,
-            id,
-            width,
-            height,
-            None,
-            std::ptr::null_mut(),
-        ))
+        unsafe {
+            from_glib_full(ffi::gdk_gl_texture_new(
+                context.to_glib_none().0,
+                id,
+                width,
+                height,
+                None,
+                std::ptr::null_mut(),
+            ))
+        }
     }
 
     #[doc(alias = "gdk_gl_texture_new")]
@@ -30,19 +32,23 @@ impl GLTexture {
         height: i32,
         release_func: F,
     ) -> Self {
-        unsafe extern "C" fn destroy_closure<F: FnOnce() + 'static>(func: glib::ffi::gpointer) {
-            let released_func = Box::<F>::from_raw(func as *mut _);
-            released_func();
+        unsafe {
+            unsafe extern "C" fn destroy_closure<F: FnOnce() + 'static>(func: glib::ffi::gpointer) {
+                unsafe {
+                    let released_func = Box::<F>::from_raw(func as *mut _);
+                    released_func();
+                }
+            }
+            let released_func = Box::new(release_func);
+            from_glib_full(ffi::gdk_gl_texture_new(
+                context.to_glib_none().0,
+                id,
+                width,
+                height,
+                Some(destroy_closure::<F>),
+                Box::into_raw(released_func) as glib::ffi::gpointer,
+            ))
         }
-        let released_func = Box::new(release_func);
-        from_glib_full(ffi::gdk_gl_texture_new(
-            context.to_glib_none().0,
-            id,
-            width,
-            height,
-            Some(destroy_closure::<F>),
-            Box::into_raw(released_func) as glib::ffi::gpointer,
-        ))
     }
 
     #[cfg(feature = "v4_12")]

gdk4/src/keys.rs

@@ -5020,11 +5020,13 @@ unsafe impl<'a> FromValue<'a> for Key {
 
     #[inline]
     unsafe fn from_value(value: &'a Value) -> Self {
-        let res: u32 = glib::gobject_ffi::g_value_get_uint(value.to_glib_none().0);
-        // As most of gdk_keyval_ apis don't really do any check for the input value
-        // (the key number) other than gdk_keyval_from_name, it is safe to not
-        // do any checks and assume people will not mis-use it
-        Key::from_glib(res)
+        unsafe {
+            let res: u32 = glib::gobject_ffi::g_value_get_uint(value.to_glib_none().0);
+            // As most of gdk_keyval_ apis don't really do any check for the input value
+            // (the key number) other than gdk_keyval_from_name, it is safe to not
+            // do any checks and assume people will not mis-use it
+            Key::from_glib(res)
+        }
     }
 }