glib: Move various assertions from FromValue to from_glib_ptr_borrow()

sdroege · sdroege · commit 1827f28c5912 · 2024-04-30T15:33:25.000+03:00
The latter is just called from the former, and the assertions are valid
for all callers of the latter.
diff --git a/glib/src/boxed.rs b/glib/src/boxed.rs
@@ -48,12 +48,22 @@ macro_rules! glib_boxed_wrapper {
             #[doc = "Borrows the underlying C value."]
             #[inline]
             pub unsafe fn from_glib_ptr_borrow(ptr: &*mut $ffi_name) -> &Self {
+                debug_assert_eq!(
+                    std::mem::size_of::<Self>(),
+                    std::mem::size_of::<$crate::ffi::gpointer>()
+                );
+                debug_assert!(!ptr.is_null());
                 &*(ptr as *const *mut $ffi_name as *const Self)
             }
 
             #[doc = "Borrows the underlying C value mutably."]
             #[inline]
             pub unsafe fn from_glib_ptr_borrow_mut(ptr: &mut *mut $ffi_name) -> &mut Self {
+                debug_assert_eq!(
+                    std::mem::size_of::<Self>(),
+                    std::mem::size_of::<$crate::ffi::gpointer>()
+                );
+                debug_assert!(!ptr.is_null());
                 &mut *(ptr as *mut *mut $ffi_name as *mut Self)
             }
         }
@@ -351,9 +361,7 @@ macro_rules! glib_boxed_wrapper {
 
             #[inline]
             unsafe fn from_value(value: &'a $crate::Value) -> Self {
-                debug_assert_eq!(std::mem::size_of::<Self>(), std::mem::size_of::<$crate::ffi::gpointer>());
                 let value = &*(value as *const $crate::Value as *const $crate::gobject_ffi::GValue);
-                debug_assert!(!value.data[0].v_pointer.is_null());
                 <$name $(<$($generic),+>)?>::from_glib_ptr_borrow(&*(&value.data[0].v_pointer as *const $crate::ffi::gpointer as *const *mut $ffi_name))
             }
         }
diff --git a/glib/src/boxed_inline.rs b/glib/src/boxed_inline.rs
@@ -172,12 +172,14 @@ macro_rules! glib_boxed_inline_wrapper {
             #[doc = "Borrows the underlying C value."]
             #[inline]
             pub unsafe fn from_glib_ptr_borrow<'a>(ptr: *const $ffi_name) -> &'a Self {
+                debug_assert!(!ptr.is_null());
                 &*(ptr as *const Self)
             }
 
             #[doc = "Borrows the underlying C value mutably."]
             #[inline]
             pub unsafe fn from_glib_ptr_borrow_mut<'a>(ptr: *mut $ffi_name) -> &'a mut Self {
+                debug_assert!(!ptr.is_null());
                 &mut *(ptr as *mut Self)
             }
         }
diff --git a/glib/src/match_info.rs b/glib/src/match_info.rs
@@ -39,6 +39,11 @@ impl MatchInfo<'_> {
     #[doc = "Borrows the underlying C value."]
     #[inline]
     pub unsafe fn from_glib_ptr_borrow(ptr: &*mut ffi::GMatchInfo) -> &Self {
+        debug_assert_eq!(
+            std::mem::size_of::<Self>(),
+            std::mem::size_of::<crate::ffi::gpointer>()
+        );
+        debug_assert!(!ptr.is_null());
         &*(ptr as *const *mut ffi::GMatchInfo as *const Self)
     }
 }
@@ -194,12 +199,7 @@ unsafe impl<'a, 'input: 'a> crate::value::FromValue<'a> for &'a MatchInfo<'input
 
     #[inline]
     unsafe fn from_value(value: &'a crate::Value) -> Self {
-        debug_assert_eq!(
-            std::mem::size_of::<Self>(),
-            std::mem::size_of::<crate::ffi::gpointer>()
-        );
         let value = &*(value as *const crate::Value as *const crate::gobject_ffi::GValue);
-        debug_assert!(!value.data[0].v_pointer.is_null());
         <MatchInfo<'input>>::from_glib_ptr_borrow(
             &*(&value.data[0].v_pointer as *const crate::ffi::gpointer
                 as *const *mut ffi::GMatchInfo),
diff --git a/glib/src/object.rs b/glib/src/object.rs
@@ -731,6 +731,12 @@ macro_rules! glib_object_wrapper {
 
             #[inline]
             unsafe fn from_glib_ptr_borrow(ptr: &*mut Self::GlibType) -> &Self {
+                debug_assert_eq!(
+                    std::mem::size_of::<Self>(),
+                    std::mem::size_of::<$crate::ffi::gpointer>()
+                );
+                debug_assert!(!ptr.is_null());
+                debug_assert_ne!((*(*ptr as *const $crate::gobject_ffi::GObject)).ref_count, 0);
                 &*(ptr as *const *mut $ffi_name as *const Self)
             }
         }
@@ -1067,10 +1073,7 @@ macro_rules! glib_object_wrapper {
 
             #[inline]
             unsafe fn from_value(value: &'a $crate::Value) -> Self {
-                debug_assert_eq!(std::mem::size_of::<Self>(), std::mem::size_of::<$crate::ffi::gpointer>());
                 let value = &*(value as *const $crate::Value as *const $crate::gobject_ffi::GValue);
-                debug_assert!(!value.data[0].v_pointer.is_null());
-                debug_assert_ne!((*(value.data[0].v_pointer as *const $crate::gobject_ffi::GObject)).ref_count, 0);
                 <$name $(<$($generic),+>)? as $crate::object::ObjectType>::from_glib_ptr_borrow(&*(&value.data[0].v_pointer as *const $crate::ffi::gpointer as *const *mut $ffi_name))
             }
         }
diff --git a/glib/src/shared.rs b/glib/src/shared.rs
@@ -46,6 +46,11 @@ macro_rules! glib_shared_wrapper {
             #[doc = "Borrows the underlying C value."]
             #[inline]
             pub unsafe fn from_glib_ptr_borrow(ptr: &*mut $ffi_name) -> &Self {
+                debug_assert_eq!(
+                    std::mem::size_of::<Self>(),
+                    std::mem::size_of::<$crate::ffi::gpointer>()
+                );
+                debug_assert!(!ptr.is_null());
                 &*(ptr as *const *mut $ffi_name as *const Self)
             }
         }
@@ -371,9 +376,7 @@ macro_rules! glib_shared_wrapper {
 
             #[inline]
             unsafe fn from_value(value: &'a $crate::Value) -> Self {
-                debug_assert_eq!(std::mem::size_of::<Self>(), std::mem::size_of::<$crate::ffi::gpointer>());
                 let value = &*(value as *const $crate::Value as *const $crate::gobject_ffi::GValue);
-                debug_assert!(!value.data[0].v_pointer.is_null());
                 <$name $(<$($generic),+>)?>::from_glib_ptr_borrow(&*(&value.data[0].v_pointer as *const $crate::ffi::gpointer as *const *mut $ffi_name))
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -172,12 +172,14 @@ macro_rules! glib_boxed_inline_wrapper {`
`172`	`172`	`#[doc = "Borrows the underlying C value."]`
`173`	`173`	`#[inline]`
`174`	`174`	`pub unsafe fn from_glib_ptr_borrow<'a>(ptr: *const $ffi_name) -> &'a Self {`
	`175`	`+ debug_assert!(!ptr.is_null());`
`175`	`176`	`&(ptr as const Self)`
`176`	`177`	`}`
`177`	`178`
`178`	`179`	`#[doc = "Borrows the underlying C value mutably."]`
`179`	`180`	`#[inline]`
`180`	`181`	`pub unsafe fn from_glib_ptr_borrow_mut<'a>(ptr: *mut $ffi_name) -> &'a mut Self {`
	`182`	`+ debug_assert!(!ptr.is_null());`
`181`	`183`	`&mut (ptr as mut Self)`
`182`	`184`	`}`
`183`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -731,6 +731,12 @@ macro_rules! glib_object_wrapper {`
`731`	`731`
`732`	`732`	`#[inline]`
`733`	`733`	`unsafe fn from_glib_ptr_borrow(ptr: &*mut Self::GlibType) -> &Self {`
	`734`	`+ debug_assert_eq!(`
	`735`	`+ std::mem::size_of::<Self>(),`
	`736`	`+ std::mem::size_of::<$crate::ffi::gpointer>()`
	`737`	`+ );`
	`738`	`+ debug_assert!(!ptr.is_null());`
	`739`	`+ debug_assert_ne!(((ptr as *const $crate::gobject_ffi::GObject)).ref_count, 0);`
`734`	`740`	`&(ptr as const mut $ffi_name as const Self)`
`735`	`741`	`}`
`736`	`742`	`}`
`@@ -1067,10 +1073,7 @@ macro_rules! glib_object_wrapper {`
`1067`	`1073`
`1068`	`1074`	`#[inline]`
`1069`	`1075`	`unsafe fn from_value(value: &'a $crate::Value) -> Self {`
`1070`		`- debug_assert_eq!(std::mem::size_of::<Self>(), std::mem::size_of::<$crate::ffi::gpointer>());`
`1071`	`1076`	`let value = &(value as const $crate::Value as *const $crate::gobject_ffi::GValue);`
`1072`		`- debug_assert!(!value.data[0].v_pointer.is_null());`
`1073`		`- debug_assert_ne!(((value.data[0].v_pointer as const $crate::gobject_ffi::GObject)).ref_count, 0);`
`1074`	`1077`	`<$name $(<$($generic),+>)? as $crate::object::ObjectType>::from_glib_ptr_borrow(&(&value.data[0].v_pointer as const $crate::ffi::gpointer as const mut $ffi_name))`
`1075`	`1078`	`}`
`1076`	`1079`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,11 @@ macro_rules! glib_shared_wrapper {`
`46`	`46`	`#[doc = "Borrows the underlying C value."]`
`47`	`47`	`#[inline]`
`48`	`48`	`pub unsafe fn from_glib_ptr_borrow(ptr: &*mut $ffi_name) -> &Self {`
	`49`	`+ debug_assert_eq!(`
	`50`	`+ std::mem::size_of::<Self>(),`
	`51`	`+ std::mem::size_of::<$crate::ffi::gpointer>()`
	`52`	`+ );`
	`53`	`+ debug_assert!(!ptr.is_null());`
`49`	`54`	`&(ptr as const mut $ffi_name as const Self)`
`50`	`55`	`}`
`51`	`56`	`}`
`@@ -371,9 +376,7 @@ macro_rules! glib_shared_wrapper {`
`371`	`376`
`372`	`377`	`#[inline]`
`373`	`378`	`unsafe fn from_value(value: &'a $crate::Value) -> Self {`
`374`		`- debug_assert_eq!(std::mem::size_of::<Self>(), std::mem::size_of::<$crate::ffi::gpointer>());`
`375`	`379`	`let value = &(value as const $crate::Value as *const $crate::gobject_ffi::GValue);`
`376`		`- debug_assert!(!value.data[0].v_pointer.is_null());`
`377`	`380`	`<$name $(<$($generic),+>)?>::from_glib_ptr_borrow(&(&value.data[0].v_pointer as const $crate::ffi::gpointer as const mut $ffi_name))`
`378`	`381`	`}`
`379`	`382`	`}`