Merge pull request #1171 from ranfdev/cleanups

sdroege · web-flow · commit fe1a41ce63ef · 2023-08-27T10:02:32.000+03:00
Use associated type in memory managers
diff --git a/glib/src/boxed.rs b/glib/src/boxed.rs
@@ -420,15 +420,17 @@ macro_rules! glib_boxed_wrapper {
 
     (@memory_manager_impl $name:ident $(<$($generic:ident $(: $bound:tt $(+ $bound2:tt)*)?),+>)?, $ffi_name:ty, @copy $copy_arg:ident $copy_expr:expr, @free $free_arg:ident $free_expr:expr) => {
         #[doc(hidden)]
-        impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::boxed::BoxedMemoryManager<$ffi_name> for $name $(<$($generic),+>)? {
+        impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::boxed::BoxedMemoryManager for $name $(<$($generic),+>)? {
+            type Target = $ffi_name;
+
             #[inline]
-            unsafe fn copy($copy_arg: *const $ffi_name) -> *mut $ffi_name {
+            unsafe fn copy($copy_arg: *const Self::Target) -> *mut Self::Target {
                 $copy_expr
             }
 
             #[inline]
             #[allow(clippy::no_effect)]
-            unsafe fn free($free_arg: *mut $ffi_name) {
+            unsafe fn free($free_arg: *mut Self::Target) {
                 $free_expr;
             }
         }
@@ -437,21 +439,23 @@ macro_rules! glib_boxed_wrapper {
 
 // The safety docs really belong in the wrapper!() macro for Boxed<T>
 /// Memory management functions for a boxed type.
-pub trait BoxedMemoryManager<T>: 'static {
+pub trait BoxedMemoryManager: 'static {
+    type Target;
+
     /// Makes a copy.
-    unsafe fn copy(ptr: *const T) -> *mut T;
+    unsafe fn copy(ptr: *const Self::Target) -> *mut Self::Target;
     /// Frees the object.
-    unsafe fn free(ptr: *mut T);
+    unsafe fn free(ptr: *mut Self::Target);
 }
 
 /// Encapsulates memory management logic for boxed types.
 #[repr(transparent)]
-pub struct Boxed<T: 'static, MM: BoxedMemoryManager<T>> {
+pub struct Boxed<T: 'static, MM: BoxedMemoryManager<Target = T>> {
     inner: ptr::NonNull<T>,
     _dummy: PhantomData<*mut MM>,
 }
 
-impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtr<'a, *const T> for Boxed<T, MM> {
+impl<'a, T: 'static, MM: BoxedMemoryManager<Target = T>> ToGlibPtr<'a, *const T> for Boxed<T, MM> {
     type Storage = PhantomData<&'a Self>;
 
     #[inline]
@@ -467,7 +471,7 @@ impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtr<'a, *const T> for Boxe
     }
 }
 
-impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtrMut<'a, *mut T> for Boxed<T, MM> {
+impl<'a, T: 'static, MM: BoxedMemoryManager<Target = T>> ToGlibPtrMut<'a, *mut T> for Boxed<T, MM> {
     type Storage = PhantomData<&'a mut Self>;
 
     #[inline]
@@ -477,7 +481,7 @@ impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtrMut<'a, *mut T> for Box
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*mut T> for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrNone<*mut T> for Boxed<T, MM> {
     #[inline]
     unsafe fn from_glib_none(ptr: *mut T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -486,7 +490,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*mut T> for Boxed<T,
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*const T> for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrNone<*const T> for Boxed<T, MM> {
     #[inline]
     unsafe fn from_glib_none(ptr: *const T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -495,7 +499,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*const T> for Boxed<
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*mut T> for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrFull<*mut T> for Boxed<T, MM> {
     #[inline]
     unsafe fn from_glib_full(ptr: *mut T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -506,7 +510,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*mut T> for Boxed<T,
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*const T> for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrFull<*const T> for Boxed<T, MM> {
     #[inline]
     unsafe fn from_glib_full(ptr: *const T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -517,7 +521,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*const T> for Boxed<
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrBorrow<*mut T> for Boxed<T, MM> {
     #[inline]
     unsafe fn from_glib_borrow(ptr: *mut T) -> Borrowed<Self> {
         debug_assert!(!ptr.is_null());
@@ -528,7 +532,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Boxed<
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> Drop for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> Drop for Boxed<T, MM> {
     #[inline]
     fn drop(&mut self) {
         unsafe {
@@ -537,36 +541,36 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> Drop for Boxed<T, MM> {
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> fmt::Debug for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> fmt::Debug for Boxed<T, MM> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Boxed").field("inner", &self.inner).finish()
     }
 }
 
-impl<T, MM: BoxedMemoryManager<T>> PartialOrd for Boxed<T, MM> {
+impl<T, MM: BoxedMemoryManager<Target = T>> PartialOrd for Boxed<T, MM> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         self.to_glib_none().0.partial_cmp(&other.to_glib_none().0)
     }
 }
 
-impl<T, MM: BoxedMemoryManager<T>> Ord for Boxed<T, MM> {
+impl<T, MM: BoxedMemoryManager<Target = T>> Ord for Boxed<T, MM> {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         self.to_glib_none().0.cmp(&other.to_glib_none().0)
     }
 }
 
-impl<T, MM: BoxedMemoryManager<T>> PartialEq for Boxed<T, MM> {
+impl<T, MM: BoxedMemoryManager<Target = T>> PartialEq for Boxed<T, MM> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         self.to_glib_none().0 == other.to_glib_none().0
     }
 }
 
-impl<T, MM: BoxedMemoryManager<T>> Eq for Boxed<T, MM> {}
+impl<T, MM: BoxedMemoryManager<Target = T>> Eq for Boxed<T, MM> {}
 
-impl<T, MM: BoxedMemoryManager<T>> Hash for Boxed<T, MM> {
+impl<T, MM: BoxedMemoryManager<Target = T>> Hash for Boxed<T, MM> {
     #[inline]
     fn hash<H>(&self, state: &mut H)
     where
@@ -576,14 +580,14 @@ impl<T, MM: BoxedMemoryManager<T>> Hash for Boxed<T, MM> {
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> Clone for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> Clone for Boxed<T, MM> {
     #[inline]
     fn clone(&self) -> Self {
         unsafe { from_glib_none(self.to_glib_none().0 as *mut T) }
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> Deref for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> Deref for Boxed<T, MM> {
     type Target = T;
 
     #[inline]
@@ -595,7 +599,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> Deref for Boxed<T, MM> {
     }
 }
 
-impl<T: 'static, MM: BoxedMemoryManager<T>> DerefMut for Boxed<T, MM> {
+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> DerefMut for Boxed<T, MM> {
     #[inline]
     fn deref_mut(&mut self) -> &mut T {
         unsafe {
diff --git a/glib/src/shared.rs b/glib/src/shared.rs
@@ -59,15 +59,17 @@ macro_rules! glib_shared_wrapper {
         }
 
         #[doc(hidden)]
-        impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::shared::SharedMemoryManager<$ffi_name> for $name $(<$($generic),+>)? {
+        impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::shared::SharedMemoryManager for $name $(<$($generic),+>)? {
+            type Target = $ffi_name;
+
             #[inline]
-            unsafe fn ref_($ref_arg: *mut $ffi_name) {
+            unsafe fn ref_($ref_arg: *mut Self::Target) {
                 $ref_expr;
             }
 
             #[inline]
             #[allow(clippy::no_effect)]
-            unsafe fn unref($unref_arg: *mut $ffi_name) {
+            unsafe fn unref($unref_arg: *mut Self::Target) {
                 $unref_expr;
             }
         }
@@ -436,29 +438,31 @@ macro_rules! glib_shared_wrapper {
     };
 }
 
-pub trait SharedMemoryManager<T> {
+pub trait SharedMemoryManager {
+    type Target;
+
     /// # Safety
     ///
     /// Callers are responsible for ensuring that a matching call to `unref`
     /// is made at an appropriate time.
-    unsafe fn ref_(ptr: *mut T);
+    unsafe fn ref_(ptr: *mut Self::Target);
 
     /// # Safety
     ///
     /// Callers are responsible for ensuring that a matching call to `ref` was
     /// made before this is called, and that the pointer is not used after the
     /// `unref` call.
-    unsafe fn unref(ptr: *mut T);
+    unsafe fn unref(ptr: *mut Self::Target);
 }
 
 /// Encapsulates memory management logic for shared types.
 #[repr(transparent)]
-pub struct Shared<T, MM: SharedMemoryManager<T>> {
+pub struct Shared<T, MM: SharedMemoryManager<Target = T>> {
     inner: ptr::NonNull<T>,
     mm: PhantomData<*const MM>,
 }
 
-impl<T, MM: SharedMemoryManager<T>> Drop for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> Drop for Shared<T, MM> {
     #[inline]
     fn drop(&mut self) {
         unsafe {
@@ -467,7 +471,7 @@ impl<T, MM: SharedMemoryManager<T>> Drop for Shared<T, MM> {
     }
 }
 
-impl<T, MM: SharedMemoryManager<T>> Clone for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> Clone for Shared<T, MM> {
     #[inline]
     fn clone(&self) -> Self {
         unsafe {
@@ -480,38 +484,38 @@ impl<T, MM: SharedMemoryManager<T>> Clone for Shared<T, MM> {
     }
 }
 
-impl<T, MM: SharedMemoryManager<T>> fmt::Debug for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> fmt::Debug for Shared<T, MM> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Shared")
             .field("inner", &self.inner)
             .finish()
     }
 }
 
-impl<T, MM: SharedMemoryManager<T>> PartialOrd for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> PartialOrd for Shared<T, MM> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         self.inner.partial_cmp(&other.inner)
     }
 }
 
-impl<T, MM: SharedMemoryManager<T>> Ord for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> Ord for Shared<T, MM> {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         self.inner.cmp(&other.inner)
     }
 }
 
-impl<T, MM: SharedMemoryManager<T>> PartialEq for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> PartialEq for Shared<T, MM> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         self.inner == other.inner
     }
 }
 
-impl<T, MM: SharedMemoryManager<T>> Eq for Shared<T, MM> {}
+impl<T, MM: SharedMemoryManager<Target = T>> Eq for Shared<T, MM> {}
 
-impl<T, MM: SharedMemoryManager<T>> Hash for Shared<T, MM> {
+impl<T, MM: SharedMemoryManager<Target = T>> Hash for Shared<T, MM> {
     #[inline]
     fn hash<H>(&self, state: &mut H)
     where
@@ -523,7 +527,7 @@ impl<T, MM: SharedMemoryManager<T>> Hash for Shared<T, MM> {
 
 impl<'a, T: 'static, MM> ToGlibPtr<'a, *mut T> for Shared<T, MM>
 where
-    MM: SharedMemoryManager<T> + 'static,
+    MM: SharedMemoryManager<Target = T> + 'static,
 {
     type Storage = PhantomData<&'a Self>;
 
@@ -541,7 +545,7 @@ where
     }
 }
 
-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*mut T> for Shared<T, MM> {
+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrNone<*mut T> for Shared<T, MM> {
     #[inline]
     unsafe fn from_glib_none(ptr: *mut T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -553,7 +557,7 @@ impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*mut T> for Shared<
     }
 }
 
-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*const T> for Shared<T, MM> {
+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrNone<*const T> for Shared<T, MM> {
     #[inline]
     unsafe fn from_glib_none(ptr: *const T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -565,7 +569,7 @@ impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*const T> for Share
     }
 }
 
-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrFull<*mut T> for Shared<T, MM> {
+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrFull<*mut T> for Shared<T, MM> {
     #[inline]
     unsafe fn from_glib_full(ptr: *mut T) -> Self {
         debug_assert!(!ptr.is_null());
@@ -576,7 +580,7 @@ impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrFull<*mut T> for Shared<
     }
 }
 
-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Shared<T, MM> {
+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrBorrow<*mut T> for Shared<T, MM> {
     #[inline]
     unsafe fn from_glib_borrow(ptr: *mut T) -> Borrowed<Self> {
         debug_assert!(!ptr.is_null());

Original file line number	Diff line number	Diff line change
`@@ -420,15 +420,17 @@ macro_rules! glib_boxed_wrapper {`
`420`	`420`
`421`	`421`	`(@memory_manager_impl $name:ident $(<$($generic:ident $(: $bound:tt $(+ $bound2:tt)*)?),+>)?, $ffi_name:ty, @copy $copy_arg:ident $copy_expr:expr, @free $free_arg:ident $free_expr:expr) => {`
`422`	`422`	`#[doc(hidden)]`
`423`		`- impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::boxed::BoxedMemoryManager<$ffi_name> for $name $(<$($generic),+>)? {`
	`423`	`+ impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::boxed::BoxedMemoryManager for $name $(<$($generic),+>)? {`
	`424`	`+ type Target = $ffi_name;`
	`425`	`+`
`424`	`426`	`#[inline]`
`425`		`- unsafe fn copy($copy_arg: const $ffi_name) -> mut $ffi_name {`
	`427`	`+ unsafe fn copy($copy_arg: const Self::Target) -> mut Self::Target {`
`426`	`428`	`$copy_expr`
`427`	`429`	`}`
`428`	`430`
`429`	`431`	`#[inline]`
`430`	`432`	`#[allow(clippy::no_effect)]`
`431`		`- unsafe fn free($free_arg: *mut $ffi_name) {`
	`433`	`+ unsafe fn free($free_arg: *mut Self::Target) {`
`432`	`434`	`$free_expr;`
`433`	`435`	`}`
`434`	`436`	`}`
`@@ -437,21 +439,23 @@ macro_rules! glib_boxed_wrapper {`
`437`	`439`
`438`	`440`	`// The safety docs really belong in the wrapper!() macro for Boxed<T>`
`439`	`441`	`/// Memory management functions for a boxed type.`
`440`		`-pub trait BoxedMemoryManager<T>: 'static {`
	`442`	`+pub trait BoxedMemoryManager: 'static {`
	`443`	`+ type Target;`
	`444`	`+`
`441`	`445`	`/// Makes a copy.`
`442`		`- unsafe fn copy(ptr: const T) -> mut T;`
	`446`	`+ unsafe fn copy(ptr: const Self::Target) -> mut Self::Target;`
`443`	`447`	`/// Frees the object.`
`444`		`- unsafe fn free(ptr: *mut T);`
	`448`	`+ unsafe fn free(ptr: *mut Self::Target);`
`445`	`449`	`}`
`446`	`450`
`447`	`451`	`/// Encapsulates memory management logic for boxed types.`
`448`	`452`	`#[repr(transparent)]`
`449`		`-pub struct Boxed<T: 'static, MM: BoxedMemoryManager<T>> {`
	`453`	`+pub struct Boxed<T: 'static, MM: BoxedMemoryManager<Target = T>> {`
`450`	`454`	`inner: ptr::NonNull<T>,`
`451`	`455`	`_dummy: PhantomData<*mut MM>,`
`452`	`456`	`}`
`453`	`457`
`454`		`-impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtr<'a, *const T> for Boxed<T, MM> {`
	`458`	`+impl<'a, T: 'static, MM: BoxedMemoryManager<Target = T>> ToGlibPtr<'a, *const T> for Boxed<T, MM> {`
`455`	`459`	`type Storage = PhantomData<&'a Self>;`
`456`	`460`
`457`	`461`	`#[inline]`
`@@ -467,7 +471,7 @@ impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtr<'a, *const T> for Boxe`
`467`	`471`	`}`
`468`	`472`	`}`
`469`	`473`
`470`		`-impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtrMut<'a, *mut T> for Boxed<T, MM> {`
	`474`	`+impl<'a, T: 'static, MM: BoxedMemoryManager<Target = T>> ToGlibPtrMut<'a, *mut T> for Boxed<T, MM> {`
`471`	`475`	`type Storage = PhantomData<&'a mut Self>;`
`472`	`476`
`473`	`477`	`#[inline]`
`@@ -477,7 +481,7 @@ impl<'a, T: 'static, MM: BoxedMemoryManager<T>> ToGlibPtrMut<'a, *mut T> for Box`
`477`	`481`	`}`
`478`	`482`	`}`
`479`	`483`
`480`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*mut T> for Boxed<T, MM> {`
	`484`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrNone<*mut T> for Boxed<T, MM> {`
`481`	`485`	`#[inline]`
`482`	`486`	`unsafe fn from_glib_none(ptr: *mut T) -> Self {`
`483`	`487`	`debug_assert!(!ptr.is_null());`
`@@ -486,7 +490,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*mut T> for Boxed<T,`
`486`	`490`	`}`
`487`	`491`	`}`
`488`	`492`
`489`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*const T> for Boxed<T, MM> {`
	`493`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrNone<*const T> for Boxed<T, MM> {`
`490`	`494`	`#[inline]`
`491`	`495`	`unsafe fn from_glib_none(ptr: *const T) -> Self {`
`492`	`496`	`debug_assert!(!ptr.is_null());`
`@@ -495,7 +499,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrNone<*const T> for Boxed<`
`495`	`499`	`}`
`496`	`500`	`}`
`497`	`501`
`498`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*mut T> for Boxed<T, MM> {`
	`502`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrFull<*mut T> for Boxed<T, MM> {`
`499`	`503`	`#[inline]`
`500`	`504`	`unsafe fn from_glib_full(ptr: *mut T) -> Self {`
`501`	`505`	`debug_assert!(!ptr.is_null());`
`@@ -506,7 +510,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*mut T> for Boxed<T,`
`506`	`510`	`}`
`507`	`511`	`}`
`508`	`512`
`509`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*const T> for Boxed<T, MM> {`
	`513`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrFull<*const T> for Boxed<T, MM> {`
`510`	`514`	`#[inline]`
`511`	`515`	`unsafe fn from_glib_full(ptr: *const T) -> Self {`
`512`	`516`	`debug_assert!(!ptr.is_null());`
`@@ -517,7 +521,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrFull<*const T> for Boxed<`
`517`	`521`	`}`
`518`	`522`	`}`
`519`	`523`
`520`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Boxed<T, MM> {`
	`524`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> FromGlibPtrBorrow<*mut T> for Boxed<T, MM> {`
`521`	`525`	`#[inline]`
`522`	`526`	`unsafe fn from_glib_borrow(ptr: *mut T) -> Borrowed<Self> {`
`523`	`527`	`debug_assert!(!ptr.is_null());`
`@@ -528,7 +532,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Boxed<`
`528`	`532`	`}`
`529`	`533`	`}`
`530`	`534`
`531`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> Drop for Boxed<T, MM> {`
	`535`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> Drop for Boxed<T, MM> {`
`532`	`536`	`#[inline]`
`533`	`537`	`fn drop(&mut self) {`
`534`	`538`	`unsafe {`
`@@ -537,36 +541,36 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> Drop for Boxed<T, MM> {`
`537`	`541`	`}`
`538`	`542`	`}`
`539`	`543`
`540`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> fmt::Debug for Boxed<T, MM> {`
	`544`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> fmt::Debug for Boxed<T, MM> {`
`541`	`545`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`542`	`546`	`f.debug_struct("Boxed").field("inner", &self.inner).finish()`
`543`	`547`	`}`
`544`	`548`	`}`
`545`	`549`
`546`		`-impl<T, MM: BoxedMemoryManager<T>> PartialOrd for Boxed<T, MM> {`
	`550`	`+impl<T, MM: BoxedMemoryManager<Target = T>> PartialOrd for Boxed<T, MM> {`
`547`	`551`	`#[inline]`
`548`	`552`	`fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {`
`549`	`553`	`self.to_glib_none().0.partial_cmp(&other.to_glib_none().0)`
`550`	`554`	`}`
`551`	`555`	`}`
`552`	`556`
`553`		`-impl<T, MM: BoxedMemoryManager<T>> Ord for Boxed<T, MM> {`
	`557`	`+impl<T, MM: BoxedMemoryManager<Target = T>> Ord for Boxed<T, MM> {`
`554`	`558`	`#[inline]`
`555`	`559`	`fn cmp(&self, other: &Self) -> cmp::Ordering {`
`556`	`560`	`self.to_glib_none().0.cmp(&other.to_glib_none().0)`
`557`	`561`	`}`
`558`	`562`	`}`
`559`	`563`
`560`		`-impl<T, MM: BoxedMemoryManager<T>> PartialEq for Boxed<T, MM> {`
	`564`	`+impl<T, MM: BoxedMemoryManager<Target = T>> PartialEq for Boxed<T, MM> {`
`561`	`565`	`#[inline]`
`562`	`566`	`fn eq(&self, other: &Self) -> bool {`
`563`	`567`	`self.to_glib_none().0 == other.to_glib_none().0`
`564`	`568`	`}`
`565`	`569`	`}`
`566`	`570`
`567`		`-impl<T, MM: BoxedMemoryManager<T>> Eq for Boxed<T, MM> {}`
	`571`	`+impl<T, MM: BoxedMemoryManager<Target = T>> Eq for Boxed<T, MM> {}`
`568`	`572`
`569`		`-impl<T, MM: BoxedMemoryManager<T>> Hash for Boxed<T, MM> {`
	`573`	`+impl<T, MM: BoxedMemoryManager<Target = T>> Hash for Boxed<T, MM> {`
`570`	`574`	`#[inline]`
`571`	`575`	`fn hash<H>(&self, state: &mut H)`
`572`	`576`	`where`
`@@ -576,14 +580,14 @@ impl<T, MM: BoxedMemoryManager<T>> Hash for Boxed<T, MM> {`
`576`	`580`	`}`
`577`	`581`	`}`
`578`	`582`
`579`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> Clone for Boxed<T, MM> {`
	`583`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> Clone for Boxed<T, MM> {`
`580`	`584`	`#[inline]`
`581`	`585`	`fn clone(&self) -> Self {`
`582`	`586`	`unsafe { from_glib_none(self.to_glib_none().0 as *mut T) }`
`583`	`587`	`}`
`584`	`588`	`}`
`585`	`589`
`586`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> Deref for Boxed<T, MM> {`
	`590`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> Deref for Boxed<T, MM> {`
`587`	`591`	`type Target = T;`
`588`	`592`
`589`	`593`	`#[inline]`
`@@ -595,7 +599,7 @@ impl<T: 'static, MM: BoxedMemoryManager<T>> Deref for Boxed<T, MM> {`
`595`	`599`	`}`
`596`	`600`	`}`
`597`	`601`
`598`		`-impl<T: 'static, MM: BoxedMemoryManager<T>> DerefMut for Boxed<T, MM> {`
	`602`	`+impl<T: 'static, MM: BoxedMemoryManager<Target = T>> DerefMut for Boxed<T, MM> {`
`599`	`603`	`#[inline]`
`600`	`604`	`fn deref_mut(&mut self) -> &mut T {`
`601`	`605`	`unsafe {`
Original file line number	Diff line number	Diff line change
`@@ -59,15 +59,17 @@ macro_rules! glib_shared_wrapper {`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`#[doc(hidden)]`
`62`		`- impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::shared::SharedMemoryManager<$ffi_name> for $name $(<$($generic),+>)? {`
	`62`	`+ impl $(<$($generic $(: $bound $(+ $bound2)*)?),+>)? $crate::shared::SharedMemoryManager for $name $(<$($generic),+>)? {`
	`63`	`+ type Target = $ffi_name;`
	`64`	`+`
`63`	`65`	`#[inline]`
`64`		`- unsafe fn ref_($ref_arg: *mut $ffi_name) {`
	`66`	`+ unsafe fn ref_($ref_arg: *mut Self::Target) {`
`65`	`67`	`$ref_expr;`
`66`	`68`	`}`
`67`	`69`
`68`	`70`	`#[inline]`
`69`	`71`	`#[allow(clippy::no_effect)]`
`70`		`- unsafe fn unref($unref_arg: *mut $ffi_name) {`
	`72`	`+ unsafe fn unref($unref_arg: *mut Self::Target) {`
`71`	`73`	`$unref_expr;`
`72`	`74`	`}`
`73`	`75`	`}`
`@@ -436,29 +438,31 @@ macro_rules! glib_shared_wrapper {`
`436`	`438`	`};`
`437`	`439`	`}`
`438`	`440`
`439`		`-pub trait SharedMemoryManager<T> {`
	`441`	`+pub trait SharedMemoryManager {`
	`442`	`+ type Target;`
	`443`	`+`
`440`	`444`	`/// # Safety`
`441`	`445`	`///`
`442`	`446`	/// Callers are responsible for ensuring that a matching call to `unref`
`443`	`447`	`/// is made at an appropriate time.`
`444`		`- unsafe fn ref_(ptr: *mut T);`
	`448`	`+ unsafe fn ref_(ptr: *mut Self::Target);`
`445`	`449`
`446`	`450`	`/// # Safety`
`447`	`451`	`///`
`448`	`452`	/// Callers are responsible for ensuring that a matching call to `ref` was
`449`	`453`	`/// made before this is called, and that the pointer is not used after the`
`450`	`454`	/// `unref` call.
`451`		`- unsafe fn unref(ptr: *mut T);`
	`455`	`+ unsafe fn unref(ptr: *mut Self::Target);`
`452`	`456`	`}`
`453`	`457`
`454`	`458`	`/// Encapsulates memory management logic for shared types.`
`455`	`459`	`#[repr(transparent)]`
`456`		`-pub struct Shared<T, MM: SharedMemoryManager<T>> {`
	`460`	`+pub struct Shared<T, MM: SharedMemoryManager<Target = T>> {`
`457`	`461`	`inner: ptr::NonNull<T>,`
`458`	`462`	`mm: PhantomData<*const MM>,`
`459`	`463`	`}`
`460`	`464`
`461`		`-impl<T, MM: SharedMemoryManager<T>> Drop for Shared<T, MM> {`
	`465`	`+impl<T, MM: SharedMemoryManager<Target = T>> Drop for Shared<T, MM> {`
`462`	`466`	`#[inline]`
`463`	`467`	`fn drop(&mut self) {`
`464`	`468`	`unsafe {`
`@@ -467,7 +471,7 @@ impl<T, MM: SharedMemoryManager<T>> Drop for Shared<T, MM> {`
`467`	`471`	`}`
`468`	`472`	`}`
`469`	`473`
`470`		`-impl<T, MM: SharedMemoryManager<T>> Clone for Shared<T, MM> {`
	`474`	`+impl<T, MM: SharedMemoryManager<Target = T>> Clone for Shared<T, MM> {`
`471`	`475`	`#[inline]`
`472`	`476`	`fn clone(&self) -> Self {`
`473`	`477`	`unsafe {`
`@@ -480,38 +484,38 @@ impl<T, MM: SharedMemoryManager<T>> Clone for Shared<T, MM> {`
`480`	`484`	`}`
`481`	`485`	`}`
`482`	`486`
`483`		`-impl<T, MM: SharedMemoryManager<T>> fmt::Debug for Shared<T, MM> {`
	`487`	`+impl<T, MM: SharedMemoryManager<Target = T>> fmt::Debug for Shared<T, MM> {`
`484`	`488`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`485`	`489`	`f.debug_struct("Shared")`
`486`	`490`	`.field("inner", &self.inner)`
`487`	`491`	`.finish()`
`488`	`492`	`}`
`489`	`493`	`}`
`490`	`494`
`491`		`-impl<T, MM: SharedMemoryManager<T>> PartialOrd for Shared<T, MM> {`
	`495`	`+impl<T, MM: SharedMemoryManager<Target = T>> PartialOrd for Shared<T, MM> {`
`492`	`496`	`#[inline]`
`493`	`497`	`fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {`
`494`	`498`	`self.inner.partial_cmp(&other.inner)`
`495`	`499`	`}`
`496`	`500`	`}`
`497`	`501`
`498`		`-impl<T, MM: SharedMemoryManager<T>> Ord for Shared<T, MM> {`
	`502`	`+impl<T, MM: SharedMemoryManager<Target = T>> Ord for Shared<T, MM> {`
`499`	`503`	`#[inline]`
`500`	`504`	`fn cmp(&self, other: &Self) -> cmp::Ordering {`
`501`	`505`	`self.inner.cmp(&other.inner)`
`502`	`506`	`}`
`503`	`507`	`}`
`504`	`508`
`505`		`-impl<T, MM: SharedMemoryManager<T>> PartialEq for Shared<T, MM> {`
	`509`	`+impl<T, MM: SharedMemoryManager<Target = T>> PartialEq for Shared<T, MM> {`
`506`	`510`	`#[inline]`
`507`	`511`	`fn eq(&self, other: &Self) -> bool {`
`508`	`512`	`self.inner == other.inner`
`509`	`513`	`}`
`510`	`514`	`}`
`511`	`515`
`512`		`-impl<T, MM: SharedMemoryManager<T>> Eq for Shared<T, MM> {}`
	`516`	`+impl<T, MM: SharedMemoryManager<Target = T>> Eq for Shared<T, MM> {}`
`513`	`517`
`514`		`-impl<T, MM: SharedMemoryManager<T>> Hash for Shared<T, MM> {`
	`518`	`+impl<T, MM: SharedMemoryManager<Target = T>> Hash for Shared<T, MM> {`
`515`	`519`	`#[inline]`
`516`	`520`	`fn hash<H>(&self, state: &mut H)`
`517`	`521`	`where`
`@@ -523,7 +527,7 @@ impl<T, MM: SharedMemoryManager<T>> Hash for Shared<T, MM> {`
`523`	`527`
`524`	`528`	`impl<'a, T: 'static, MM> ToGlibPtr<'a, *mut T> for Shared<T, MM>`
`525`	`529`	`where`
`526`		`- MM: SharedMemoryManager<T> + 'static,`
	`530`	`+ MM: SharedMemoryManager<Target = T> + 'static,`
`527`	`531`	`{`
`528`	`532`	`type Storage = PhantomData<&'a Self>;`
`529`	`533`
`@@ -541,7 +545,7 @@ where`
`541`	`545`	`}`
`542`	`546`	`}`
`543`	`547`
`544`		`-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*mut T> for Shared<T, MM> {`
	`548`	`+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrNone<*mut T> for Shared<T, MM> {`
`545`	`549`	`#[inline]`
`546`	`550`	`unsafe fn from_glib_none(ptr: *mut T) -> Self {`
`547`	`551`	`debug_assert!(!ptr.is_null());`
`@@ -553,7 +557,7 @@ impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*mut T> for Shared<`
`553`	`557`	`}`
`554`	`558`	`}`
`555`	`559`
`556`		`-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*const T> for Shared<T, MM> {`
	`560`	`+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrNone<*const T> for Shared<T, MM> {`
`557`	`561`	`#[inline]`
`558`	`562`	`unsafe fn from_glib_none(ptr: *const T) -> Self {`
`559`	`563`	`debug_assert!(!ptr.is_null());`
`@@ -565,7 +569,7 @@ impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*const T> for Share`
`565`	`569`	`}`
`566`	`570`	`}`
`567`	`571`
`568`		`-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrFull<*mut T> for Shared<T, MM> {`
	`572`	`+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrFull<*mut T> for Shared<T, MM> {`
`569`	`573`	`#[inline]`
`570`	`574`	`unsafe fn from_glib_full(ptr: *mut T) -> Self {`
`571`	`575`	`debug_assert!(!ptr.is_null());`
`@@ -576,7 +580,7 @@ impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrFull<*mut T> for Shared<`
`576`	`580`	`}`
`577`	`581`	`}`
`578`	`582`
`579`		`-impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Shared<T, MM> {`
	`583`	`+impl<T: 'static, MM: SharedMemoryManager<Target = T>> FromGlibPtrBorrow<*mut T> for Shared<T, MM> {`
`580`	`584`	`#[inline]`
`581`	`585`	`unsafe fn from_glib_borrow(ptr: *mut T) -> Borrowed<Self> {`
`582`	`586`	`debug_assert!(!ptr.is_null());`