From bf09d820b8067689091e7c399b4616b62136ef4b Mon Sep 17 00:00:00 2001
From: Fina Wilke <code@felinira.net>
Date: Sun, 29 Sep 2024 16:39:52 +0200
Subject: [PATCH] gio: Add additional type bounds to Impl traits

Remove the Sealed traits, as they are now unnecessary.
---
 gdk-pixbuf/src/subclass/pixbuf_animation.rs   | 11 +--
 .../src/subclass/pixbuf_animation_iter.rs     | 11 +--
 gdk-pixbuf/src/subclass/pixbuf_loader.rs      | 11 +--
 gio/src/subclass/action_group.rs              | 87 ++++++++++++++-----
 gio/src/subclass/action_map.rs                | 32 ++++---
 gio/src/subclass/application.rs               | 75 +++++++++++-----
 gio/src/subclass/async_initable.rs            | 30 ++++---
 gio/src/subclass/initable.rs                  | 27 +++---
 gio/src/subclass/input_stream.rs              | 41 ++++++---
 gio/src/subclass/io_stream.rs                 | 37 +++++---
 gio/src/subclass/list_model.rs                | 25 +++---
 gio/src/subclass/output_stream.rs             | 45 +++++++---
 gio/src/subclass/seekable.rs                  | 47 +++++++---
 gio/src/subclass/socket_control_message.rs    | 49 ++++++++---
 glib/src/subclass/type_module.rs              |  4 +-
 glib/src/subclass/type_plugin.rs              |  4 +-
 16 files changed, 349 insertions(+), 187 deletions(-)

diff --git a/gdk-pixbuf/src/subclass/pixbuf_animation.rs b/gdk-pixbuf/src/subclass/pixbuf_animation.rs
index d51da8c3866b..ee5ff297496d 100644
--- a/gdk-pixbuf/src/subclass/pixbuf_animation.rs
+++ b/gdk-pixbuf/src/subclass/pixbuf_animation.rs
@@ -34,16 +34,7 @@ where
     }
 }
 
-mod sealed {
-    use glib::{prelude::*, subclass::prelude::*};
-    pub trait Sealed {}
-    impl<T: super::PixbufAnimationImplExt> Sealed for T where
-        <T as ObjectSubclass>::Type: IsA<super::PixbufAnimation>
-    {
-    }
-}
-
-pub trait PixbufAnimationImplExt: sealed::Sealed + ObjectSubclass
+pub trait PixbufAnimationImplExt: ObjectSubclass + PixbufAnimationImpl
 where
     <Self as ObjectSubclass>::Type: IsA<PixbufAnimation>,
 {
diff --git a/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs b/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs
index 4b97b5098e6d..03e16a1db22c 100644
--- a/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs
+++ b/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs
@@ -35,16 +35,7 @@ where
     }
 }
 
-mod sealed {
-    use glib::{prelude::*, subclass::prelude::*};
-    pub trait Sealed {}
-    impl<T: super::PixbufAnimationIterImplExt> Sealed for T where
-        <T as ObjectSubclass>::Type: IsA<super::PixbufAnimationIter>
-    {
-    }
-}
-
-pub trait PixbufAnimationIterImplExt: sealed::Sealed + ObjectSubclass
+pub trait PixbufAnimationIterImplExt: ObjectSubclass + PixbufAnimationIterImpl
 where
     <Self as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
 {
diff --git a/gdk-pixbuf/src/subclass/pixbuf_loader.rs b/gdk-pixbuf/src/subclass/pixbuf_loader.rs
index 01d152cb33f8..e99388644043 100644
--- a/gdk-pixbuf/src/subclass/pixbuf_loader.rs
+++ b/gdk-pixbuf/src/subclass/pixbuf_loader.rs
@@ -28,16 +28,7 @@ where
     }
 }
 
-mod sealed {
-    use glib::{prelude::*, subclass::prelude::*};
-    pub trait Sealed {}
-    impl<T: super::PixbufLoaderImplExt> Sealed for T where
-        <Self as ObjectSubclass>::Type: IsA<super::PixbufLoader>
-    {
-    }
-}
-
-pub trait PixbufLoaderImplExt: sealed::Sealed + ObjectSubclass
+pub trait PixbufLoaderImplExt: ObjectSubclass + PixbufLoaderImpl
 where
     <Self as ObjectSubclass>::Type: IsA<PixbufLoader>,
 {
diff --git a/gio/src/subclass/action_group.rs b/gio/src/subclass/action_group.rs
index 948fb2d318c8..ca895077889a 100644
--- a/gio/src/subclass/action_group.rs
+++ b/gio/src/subclass/action_group.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, GString, Quark, Varia
 
 use crate::{ffi, ActionGroup};
 
-pub trait ActionGroupImpl: ObjectImpl {
+pub trait ActionGroupImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     fn action_added(&self, action_name: &str) {
         self.parent_action_added(action_name);
     }
@@ -73,12 +76,10 @@ pub trait ActionGroupImpl: ObjectImpl {
     )>;
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ActionGroupImplExt> Sealed for T {}
-}
-
-pub trait ActionGroupImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ActionGroupImplExt: ObjectSubclass + ActionGroupImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     fn parent_action_added(&self, action_name: &str) {
         unsafe {
             let type_data = Self::type_data();
@@ -341,9 +342,13 @@ pub trait ActionGroupImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ActionGroupImpl> ActionGroupImplExt for T {}
+impl<T: ActionGroupImpl> ActionGroupImplExt for T where <T as ObjectSubclass>::Type: IsA<ActionGroup>
+{}
 
-unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup {
+unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
 
@@ -367,7 +372,10 @@ unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup {
 unsafe extern "C" fn action_group_has_action<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let action_name = GString::from_glib_borrow(action_nameptr);
     let imp = instance.imp();
@@ -378,7 +386,10 @@ unsafe extern "C" fn action_group_has_action<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_enabled<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -399,7 +410,10 @@ impl<T, F: Fn(*mut T) + 'static> Drop for PtrHolder<T, F> {
 unsafe extern "C" fn action_group_get_action_parameter_type<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *const glib::ffi::GVariantType {
+) -> *const glib::ffi::GVariantType
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -428,7 +442,10 @@ unsafe extern "C" fn action_group_get_action_parameter_type<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_state_type<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *const glib::ffi::GVariantType {
+) -> *const glib::ffi::GVariantType
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -457,7 +474,10 @@ unsafe extern "C" fn action_group_get_action_state_type<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_state_hint<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *mut glib::ffi::GVariant {
+) -> *mut glib::ffi::GVariant
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -485,7 +505,10 @@ unsafe extern "C" fn action_group_get_action_state_hint<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_state<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *mut glib::ffi::GVariant {
+) -> *mut glib::ffi::GVariant
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -512,7 +535,9 @@ unsafe extern "C" fn action_group_change_action_state<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     stateptr: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -525,7 +550,9 @@ unsafe extern "C" fn action_group_activate_action<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     parameterptr: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -537,7 +564,9 @@ unsafe extern "C" fn action_group_activate_action<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_action_added<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -548,7 +577,9 @@ unsafe extern "C" fn action_group_action_added<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_action_removed<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -560,7 +591,9 @@ unsafe extern "C" fn action_group_action_enabled_changed<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     enabled: glib::ffi::gboolean,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -572,7 +605,9 @@ unsafe extern "C" fn action_group_action_state_changed<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     stateptr: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -583,7 +618,10 @@ unsafe extern "C" fn action_group_action_state_changed<T: ActionGroupImpl>(
 
 unsafe extern "C" fn action_group_list_actions<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
-) -> *mut *mut libc::c_char {
+) -> *mut *mut libc::c_char
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
 
@@ -609,7 +647,10 @@ unsafe extern "C" fn action_group_query_action<T: ActionGroupImpl>(
     state_type: *mut *const glib::ffi::GVariantType,
     state_hint: *mut *mut glib::ffi::GVariant,
     state: *mut *mut glib::ffi::GVariant,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
diff --git a/gio/src/subclass/action_map.rs b/gio/src/subclass/action_map.rs
index d7a668ee33e7..13b21ca01afc 100644
--- a/gio/src/subclass/action_map.rs
+++ b/gio/src/subclass/action_map.rs
@@ -6,18 +6,19 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, GString, Quark};
 
 use crate::{ffi, Action, ActionMap};
 
-pub trait ActionMapImpl: ObjectImpl {
+pub trait ActionMapImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     fn lookup_action(&self, action_name: &str) -> Option<Action>;
     fn add_action(&self, action: &Action);
     fn remove_action(&self, action_name: &str);
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ActionMapImplExt> Sealed for T {}
-}
-
-pub trait ActionMapImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ActionMapImplExt: ObjectSubclass + ActionMapImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     fn parent_lookup_action(&self, name: &str) -> Option<Action> {
         unsafe {
             let type_data = Self::type_data();
@@ -68,11 +69,11 @@ pub trait ActionMapImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ActionMapImpl> ActionMapImplExt for T {}
+impl<T: ActionMapImpl> ActionMapImplExt for T where <T as ObjectSubclass>::Type: IsA<ActionMap> {}
 
 unsafe impl<T: ActionMapImpl> IsImplementable<T> for ActionMap
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
 {
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
@@ -86,7 +87,10 @@ where
 unsafe extern "C" fn action_map_lookup_action<T: ActionMapImpl>(
     action_map: *mut ffi::GActionMap,
     action_nameptr: *const libc::c_char,
-) -> *mut ffi::GAction {
+) -> *mut ffi::GAction
+where
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     let instance = &*(action_map as *mut T::Instance);
     let action_name = GString::from_glib_borrow(action_nameptr);
     let imp = instance.imp();
@@ -116,7 +120,9 @@ unsafe extern "C" fn action_map_lookup_action<T: ActionMapImpl>(
 unsafe extern "C" fn action_map_add_action<T: ActionMapImpl>(
     action_map: *mut ffi::GActionMap,
     actionptr: *mut ffi::GAction,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     let instance = &*(action_map as *mut T::Instance);
     let imp = instance.imp();
     let action: Borrowed<Action> = from_glib_borrow(actionptr);
@@ -127,7 +133,9 @@ unsafe extern "C" fn action_map_add_action<T: ActionMapImpl>(
 unsafe extern "C" fn action_map_remove_action<T: ActionMapImpl>(
     action_map: *mut ffi::GActionMap,
     action_nameptr: *const libc::c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     let instance = &*(action_map as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
diff --git a/gio/src/subclass/application.rs b/gio/src/subclass/application.rs
index 5a863c388d17..b9962f15078d 100644
--- a/gio/src/subclass/application.rs
+++ b/gio/src/subclass/application.rs
@@ -64,7 +64,10 @@ impl From<ArgumentList> for Vec<OsString> {
     }
 }
 
-pub trait ApplicationImpl: ObjectImpl + ApplicationImplExt {
+pub trait ApplicationImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Application>,
+{
     fn activate(&self) {
         self.parent_activate()
     }
@@ -110,12 +113,10 @@ pub trait ApplicationImpl: ObjectImpl + ApplicationImplExt {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ApplicationImplExt> Sealed for T {}
-}
-
-pub trait ApplicationImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ApplicationImplExt: ObjectSubclass + ApplicationImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Application>,
+{
     fn parent_activate(&self) {
         unsafe {
             let data = Self::type_data();
@@ -271,9 +272,13 @@ pub trait ApplicationImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ApplicationImpl> ApplicationImplExt for T {}
+impl<T: ApplicationImpl> ApplicationImplExt for T where <T as ObjectSubclass>::Type: IsA<Application>
+{}
 
-unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application {
+unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -292,7 +297,10 @@ unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application {
     }
 }
 
-unsafe extern "C" fn application_activate<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_activate<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -302,7 +310,9 @@ unsafe extern "C" fn application_activate<T: ApplicationImpl>(ptr: *mut ffi::GAp
 unsafe extern "C" fn application_after_emit<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     platform_data: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -311,7 +321,9 @@ unsafe extern "C" fn application_after_emit<T: ApplicationImpl>(
 unsafe extern "C" fn application_before_emit<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     platform_data: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -320,7 +332,10 @@ unsafe extern "C" fn application_before_emit<T: ApplicationImpl>(
 unsafe extern "C" fn application_command_line<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     command_line: *mut ffi::GApplicationCommandLine,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -330,7 +345,10 @@ unsafe extern "C" fn application_local_command_line<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     arguments: *mut *mut *mut c_char,
     exit_status: *mut i32,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -351,32 +369,46 @@ unsafe extern "C" fn application_open<T: ApplicationImpl>(
     files: *mut *mut ffi::GFile,
     num_files: i32,
     hint: *const c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     let files: Vec<crate::File> = FromGlibContainer::from_glib_none_num(files, num_files as usize);
     imp.open(files.as_slice(), &glib::GString::from_glib_borrow(hint))
 }
-unsafe extern "C" fn application_quit_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_quit_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.quit_mainloop()
 }
-unsafe extern "C" fn application_run_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_run_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.run_mainloop()
 }
-unsafe extern "C" fn application_shutdown<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_shutdown<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.shutdown()
 }
-unsafe extern "C" fn application_startup<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_startup<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -386,7 +418,10 @@ unsafe extern "C" fn application_startup<T: ApplicationImpl>(ptr: *mut ffi::GApp
 unsafe extern "C" fn application_handle_local_options<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     options: *mut glib::ffi::GVariantDict,
-) -> c_int {
+) -> c_int
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/async_initable.rs b/gio/src/subclass/async_initable.rs
index 1c2171bcfa55..433ae27ac68d 100644
--- a/gio/src/subclass/async_initable.rs
+++ b/gio/src/subclass/async_initable.rs
@@ -8,7 +8,10 @@ use crate::{
     ffi, AsyncInitable, AsyncResult, Cancellable, CancellableFuture, GioFutureResult, LocalTask,
 };
 
-pub trait AsyncInitableImpl: ObjectImpl {
+pub trait AsyncInitableImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     fn init_future(
         &self,
         io_priority: glib::Priority,
@@ -17,12 +20,10 @@ pub trait AsyncInitableImpl: ObjectImpl {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::AsyncInitableImplExt> Sealed for T {}
-}
-
-pub trait AsyncInitableImplExt: sealed::Sealed + AsyncInitableImpl + ObjectSubclass {
+pub trait AsyncInitableImplExt: ObjectSubclass + AsyncInitableImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     fn parent_init_future(
         &self,
         io_priority: glib::Priority,
@@ -42,6 +43,7 @@ pub trait AsyncInitableImplExt: sealed::Sealed + AsyncInitableImpl + ObjectSubcl
                 user_data: glib::ffi::gpointer,
             ) where
                 T: AsyncInitableImpl,
+                <T as ObjectSubclass>::Type: IsA<AsyncInitable>,
             {
                 let type_data = T::type_data();
                 let parent_iface = type_data.as_ref().parent_interface::<AsyncInitable>()
@@ -83,9 +85,15 @@ pub trait AsyncInitableImplExt: sealed::Sealed + AsyncInitableImpl + ObjectSubcl
     }
 }
 
-impl<T: AsyncInitableImpl> AsyncInitableImplExt for T {}
+impl<T: AsyncInitableImpl> AsyncInitableImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<AsyncInitable>
+{
+}
 
-unsafe impl<T: AsyncInitableImpl> IsImplementable<T> for AsyncInitable {
+unsafe impl<T: AsyncInitableImpl> IsImplementable<T> for AsyncInitable
+where
+    <T as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
         iface.init_async = Some(async_initable_init_async::<T>);
@@ -99,7 +107,9 @@ unsafe extern "C" fn async_initable_init_async<T: AsyncInitableImpl>(
     cancellable: *mut ffi::GCancellable,
     callback: ffi::GAsyncReadyCallback,
     user_data: glib::ffi::gpointer,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     let instance = &*(initable as *mut T::Instance);
     let imp = instance.imp();
     let cancellable = Option::<Cancellable>::from_glib_none(cancellable);
diff --git a/gio/src/subclass/initable.rs b/gio/src/subclass/initable.rs
index 23b4beb7fc8e..9ad33d9bd364 100644
--- a/gio/src/subclass/initable.rs
+++ b/gio/src/subclass/initable.rs
@@ -6,18 +6,19 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, Initable};
 
-pub trait InitableImpl: ObjectImpl {
+pub trait InitableImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Initable>,
+{
     fn init(&self, cancellable: Option<&Cancellable>) -> Result<(), Error> {
         self.parent_init(cancellable)
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::InitableImplExt> Sealed for T {}
-}
-
-pub trait InitableImplExt: sealed::Sealed + ObjectSubclass {
+pub trait InitableImplExt: ObjectSubclass + InitableImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Initable>,
+{
     fn parent_init(&self, cancellable: Option<&Cancellable>) -> Result<(), Error> {
         unsafe {
             let type_data = Self::type_data();
@@ -44,9 +45,12 @@ pub trait InitableImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: InitableImpl> InitableImplExt for T {}
+impl<T: InitableImpl> InitableImplExt for T where <Self as ObjectSubclass>::Type: IsA<Initable> {}
 
-unsafe impl<T: InitableImpl> IsImplementable<T> for Initable {
+unsafe impl<T: InitableImpl> IsImplementable<T> for Initable
+where
+    <T as ObjectSubclass>::Type: IsA<Initable>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
         iface.init = Some(initable_init::<T>);
@@ -57,7 +61,10 @@ unsafe extern "C" fn initable_init<T: InitableImpl>(
     initable: *mut ffi::GInitable,
     cancellable: *mut ffi::GCancellable,
     error: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Initable>,
+{
     let instance = &*(initable as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/input_stream.rs b/gio/src/subclass/input_stream.rs
index e65e27678791..7d8f97c48722 100644
--- a/gio/src/subclass/input_stream.rs
+++ b/gio/src/subclass/input_stream.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, InputStream};
 
-pub trait InputStreamImpl: ObjectImpl + InputStreamImplExt + Send {
+pub trait InputStreamImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<InputStream>,
+{
     fn read(&self, buffer: &mut [u8], cancellable: Option<&Cancellable>) -> Result<usize, Error> {
         self.parent_read(buffer, cancellable)
     }
@@ -20,12 +23,10 @@ pub trait InputStreamImpl: ObjectImpl + InputStreamImplExt + Send {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::InputStreamImplExt> Sealed for T {}
-}
-
-pub trait InputStreamImplExt: sealed::Sealed + ObjectSubclass {
+pub trait InputStreamImplExt: ObjectSubclass + InputStreamImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<InputStream>,
+{
     fn parent_read(
         &self,
         buffer: &mut [u8],
@@ -103,9 +104,13 @@ pub trait InputStreamImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: InputStreamImpl> InputStreamImplExt for T {}
+impl<T: InputStreamImpl> InputStreamImplExt for T where <T as ObjectSubclass>::Type: IsA<InputStream>
+{}
 
-unsafe impl<T: InputStreamImpl> IsSubclassable<T> for InputStream {
+unsafe impl<T: InputStreamImpl> IsSubclassable<T> for InputStream
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -122,7 +127,10 @@ unsafe extern "C" fn stream_read<T: InputStreamImpl>(
     count: usize,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     debug_assert!(count <= isize::MAX as usize);
 
     let instance = &*(ptr as *mut T::Instance);
@@ -156,7 +164,10 @@ unsafe extern "C" fn stream_close<T: InputStreamImpl>(
     ptr: *mut ffi::GInputStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -180,7 +191,10 @@ unsafe extern "C" fn stream_skip<T: InputStreamImpl>(
     count: usize,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     debug_assert!(count <= isize::MAX as usize);
 
     let instance = &*(ptr as *mut T::Instance);
@@ -299,7 +313,8 @@ mod tests {
 
     glib::wrapper! {
         pub struct SimpleInputStream(ObjectSubclass<imp::SimpleInputStream>)
-            @extends InputStream;
+            @extends InputStream,
+            @implements crate::Seekable;
     }
 
     #[test]
diff --git a/gio/src/subclass/io_stream.rs b/gio/src/subclass/io_stream.rs
index 6a3b290c7049..fed6b9aeb6ca 100644
--- a/gio/src/subclass/io_stream.rs
+++ b/gio/src/subclass/io_stream.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, IOStream, InputStream, OutputStream};
 
-pub trait IOStreamImpl: ObjectImpl + IOStreamImplExt + Send {
+pub trait IOStreamImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<IOStream>,
+{
     fn input_stream(&self) -> InputStream {
         self.parent_input_stream()
     }
@@ -20,12 +23,10 @@ pub trait IOStreamImpl: ObjectImpl + IOStreamImplExt + Send {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::IOStreamImplExt> Sealed for T {}
-}
-
-pub trait IOStreamImplExt: sealed::Sealed + ObjectSubclass {
+pub trait IOStreamImplExt: ObjectSubclass + IOStreamImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<IOStream>,
+{
     fn parent_input_stream(&self) -> InputStream {
         unsafe {
             let data = Self::type_data();
@@ -70,9 +71,12 @@ pub trait IOStreamImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: IOStreamImpl> IOStreamImplExt for T {}
+impl<T: IOStreamImpl> IOStreamImplExt for T where <T as ObjectSubclass>::Type: IsA<IOStream> {}
 
-unsafe impl<T: IOStreamImpl> IsSubclassable<T> for IOStream {
+unsafe impl<T: IOStreamImpl> IsSubclassable<T> for IOStream
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -85,7 +89,10 @@ unsafe impl<T: IOStreamImpl> IsSubclassable<T> for IOStream {
 
 unsafe extern "C" fn stream_get_input_stream<T: IOStreamImpl>(
     ptr: *mut ffi::GIOStream,
-) -> *mut ffi::GInputStream {
+) -> *mut ffi::GInputStream
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -112,7 +119,10 @@ unsafe extern "C" fn stream_get_input_stream<T: IOStreamImpl>(
 
 unsafe extern "C" fn stream_get_output_stream<T: IOStreamImpl>(
     ptr: *mut ffi::GIOStream,
-) -> *mut ffi::GOutputStream {
+) -> *mut ffi::GOutputStream
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -141,7 +151,10 @@ unsafe extern "C" fn stream_close<T: IOStreamImpl>(
     ptr: *mut ffi::GIOStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/list_model.rs b/gio/src/subclass/list_model.rs
index 96a411f3595b..8223739d7a6e 100644
--- a/gio/src/subclass/list_model.rs
+++ b/gio/src/subclass/list_model.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, ListModel};
 
-pub trait ListModelImpl: ObjectImpl {
+pub trait ListModelImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ListModel>,
+{
     #[doc(alias = "get_item_type")]
     fn item_type(&self) -> glib::Type;
     #[doc(alias = "get_n_items")]
@@ -15,12 +18,10 @@ pub trait ListModelImpl: ObjectImpl {
     fn item(&self, position: u32) -> Option<glib::Object>;
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ListModelImplExt> Sealed for T {}
-}
-
-pub trait ListModelImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ListModelImplExt: ObjectSubclass + ListModelImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ListModel>,
+{
     fn parent_item_type(&self) -> glib::Type {
         unsafe {
             let type_data = Self::type_data();
@@ -66,11 +67,11 @@ pub trait ListModelImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ListModelImpl> ListModelImplExt for T {}
+impl<T: ListModelImpl> ListModelImplExt for T where <T as ObjectSubclass>::Type: IsA<ListModel> {}
 
 unsafe impl<T: ListModelImpl> IsImplementable<T> for ListModel
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
@@ -85,7 +86,7 @@ unsafe extern "C" fn list_model_get_item_type<T: ListModelImpl>(
     list_model: *mut ffi::GListModel,
 ) -> glib::ffi::GType
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     let instance = &*(list_model as *mut T::Instance);
     let imp = instance.imp();
@@ -117,7 +118,7 @@ unsafe extern "C" fn list_model_get_n_items<T: ListModelImpl>(
     list_model: *mut ffi::GListModel,
 ) -> u32
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     let instance = &*(list_model as *mut T::Instance);
     let imp = instance.imp();
@@ -130,7 +131,7 @@ unsafe extern "C" fn list_model_get_item<T: ListModelImpl>(
     position: u32,
 ) -> *mut glib::gobject_ffi::GObject
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     let instance = &*(list_model as *mut T::Instance);
     let imp = instance.imp();
diff --git a/gio/src/subclass/output_stream.rs b/gio/src/subclass/output_stream.rs
index 6f9d8ec86c6c..e3836fad748d 100644
--- a/gio/src/subclass/output_stream.rs
+++ b/gio/src/subclass/output_stream.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, InputStream, OutputStream, OutputStreamSpliceFlags};
 
-pub trait OutputStreamImpl: ObjectImpl + OutputStreamImplExt + Send {
+pub trait OutputStreamImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     fn write(&self, buffer: &[u8], cancellable: Option<&Cancellable>) -> Result<usize, Error> {
         self.parent_write(buffer, cancellable)
     }
@@ -29,12 +32,10 @@ pub trait OutputStreamImpl: ObjectImpl + OutputStreamImplExt + Send {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::OutputStreamImplExt> Sealed for T {}
-}
-
-pub trait OutputStreamImplExt: sealed::Sealed + ObjectSubclass {
+pub trait OutputStreamImplExt: ObjectSubclass + OutputStreamImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     fn parent_write(
         &self,
         buffer: &[u8],
@@ -150,9 +151,15 @@ pub trait OutputStreamImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: OutputStreamImpl> OutputStreamImplExt for T {}
+impl<T: OutputStreamImpl> OutputStreamImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>
+{
+}
 
-unsafe impl<T: OutputStreamImpl> IsSubclassable<T> for OutputStream {
+unsafe impl<T: OutputStreamImpl> IsSubclassable<T> for OutputStream
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -170,7 +177,10 @@ unsafe extern "C" fn stream_write<T: OutputStreamImpl>(
     count: usize,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     debug_assert!(count <= isize::MAX as usize);
 
     let instance = &*(ptr as *mut T::Instance);
@@ -204,7 +214,10 @@ unsafe extern "C" fn stream_close<T: OutputStreamImpl>(
     ptr: *mut ffi::GOutputStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -227,7 +240,10 @@ unsafe extern "C" fn stream_flush<T: OutputStreamImpl>(
     ptr: *mut ffi::GOutputStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -252,7 +268,10 @@ unsafe extern "C" fn stream_splice<T: OutputStreamImpl>(
     flags: ffi::GOutputStreamSpliceFlags,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/seekable.rs b/gio/src/subclass/seekable.rs
index 3d23db1e5a23..dd8a70f2ddeb 100644
--- a/gio/src/subclass/seekable.rs
+++ b/gio/src/subclass/seekable.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error, SeekType};
 
 use crate::{ffi, Cancellable, Seekable};
 
-pub trait SeekableImpl: ObjectImpl + Send {
+pub trait SeekableImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<Seekable>,
+{
     fn tell(&self) -> i64;
     fn can_seek(&self) -> bool;
     fn seek(
@@ -19,12 +22,10 @@ pub trait SeekableImpl: ObjectImpl + Send {
     fn truncate(&self, offset: i64, cancellable: Option<&Cancellable>) -> Result<(), Error>;
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::SeekableImplExt> Sealed for T {}
-}
-
-pub trait SeekableImplExt: sealed::Sealed + ObjectSubclass {
+pub trait SeekableImplExt: ObjectSubclass + SeekableImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Seekable>,
+{
     fn parent_tell(&self) -> i64 {
         unsafe {
             let type_data = Self::type_data();
@@ -125,9 +126,12 @@ pub trait SeekableImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: SeekableImpl> SeekableImplExt for T {}
+impl<T: SeekableImpl> SeekableImplExt for T where <T as ObjectSubclass>::Type: IsA<Seekable> {}
 
-unsafe impl<T: SeekableImpl> IsImplementable<T> for Seekable {
+unsafe impl<T: SeekableImpl> IsImplementable<T> for Seekable
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
 
@@ -139,7 +143,10 @@ unsafe impl<T: SeekableImpl> IsImplementable<T> for Seekable {
     }
 }
 
-unsafe extern "C" fn seekable_tell<T: SeekableImpl>(seekable: *mut ffi::GSeekable) -> i64 {
+unsafe extern "C" fn seekable_tell<T: SeekableImpl>(seekable: *mut ffi::GSeekable) -> i64
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -148,7 +155,10 @@ unsafe extern "C" fn seekable_tell<T: SeekableImpl>(seekable: *mut ffi::GSeekabl
 
 unsafe extern "C" fn seekable_can_seek<T: SeekableImpl>(
     seekable: *mut ffi::GSeekable,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -161,7 +171,10 @@ unsafe extern "C" fn seekable_seek<T: SeekableImpl>(
     type_: glib::ffi::GSeekType,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -184,7 +197,10 @@ unsafe extern "C" fn seekable_seek<T: SeekableImpl>(
 
 unsafe extern "C" fn seekable_can_truncate<T: SeekableImpl>(
     seekable: *mut ffi::GSeekable,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -196,7 +212,10 @@ unsafe extern "C" fn seekable_truncate<T: SeekableImpl>(
     offset: i64,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/socket_control_message.rs b/gio/src/subclass/socket_control_message.rs
index 3f43ac1608e1..6eed7637fb7a 100644
--- a/gio/src/subclass/socket_control_message.rs
+++ b/gio/src/subclass/socket_control_message.rs
@@ -4,7 +4,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, SocketControlMessage};
 
-pub trait SocketControlMessageImpl: ObjectImpl + SocketControlMessageImplExt {
+pub trait SocketControlMessageImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     fn level(&self) -> i32 {
         self.parent_level()
     }
@@ -26,12 +29,10 @@ pub trait SocketControlMessageImpl: ObjectImpl + SocketControlMessageImplExt {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::SocketControlMessageImplExt> Sealed for T {}
-}
-
-pub trait SocketControlMessageImplExt: sealed::Sealed + ObjectSubclass {
+pub trait SocketControlMessageImplExt: ObjectSubclass + SocketControlMessageImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     fn parent_level(&self) -> i32 {
         unsafe {
             let data = Self::type_data();
@@ -113,9 +114,15 @@ pub trait SocketControlMessageImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: SocketControlMessageImpl> SocketControlMessageImplExt for T {}
+impl<T: SocketControlMessageImpl> SocketControlMessageImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>
+{
+}
 
-unsafe impl<T: SocketControlMessageImpl> IsSubclassable<T> for SocketControlMessage {
+unsafe impl<T: SocketControlMessageImpl> IsSubclassable<T> for SocketControlMessage
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -130,7 +137,10 @@ unsafe impl<T: SocketControlMessageImpl> IsSubclassable<T> for SocketControlMess
 
 unsafe extern "C" fn socket_control_message_get_level<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -139,7 +149,10 @@ unsafe extern "C" fn socket_control_message_get_level<T: SocketControlMessageImp
 
 unsafe extern "C" fn socket_control_message_get_type<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -148,7 +161,10 @@ unsafe extern "C" fn socket_control_message_get_type<T: SocketControlMessageImpl
 
 unsafe extern "C" fn socket_control_message_get_size<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
-) -> usize {
+) -> usize
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -158,7 +174,9 @@ unsafe extern "C" fn socket_control_message_get_size<T: SocketControlMessageImpl
 unsafe extern "C" fn socket_control_message_serialize<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
     data: glib::ffi::gpointer,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -172,7 +190,10 @@ unsafe extern "C" fn socket_control_message_deserialize<T: SocketControlMessageI
     type_: i32,
     size: usize,
     data: glib::ffi::gpointer,
-) -> *mut ffi::GSocketControlMessage {
+) -> *mut ffi::GSocketControlMessage
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let data = std::slice::from_raw_parts(data as *mut u8, size);
 
     T::deserialize(level, type_, data).into_glib_ptr()
diff --git a/glib/src/subclass/type_module.rs b/glib/src/subclass/type_module.rs
index c93a22cbb167..cd78adade1ab 100644
--- a/glib/src/subclass/type_module.rs
+++ b/glib/src/subclass/type_module.rs
@@ -2,7 +2,7 @@
 
 use crate::{ffi, gobject_ffi, prelude::*, subclass::prelude::*, translate::*, TypeModule};
 
-pub trait TypeModuleImpl: ObjectImpl + TypeModuleImplExt
+pub trait TypeModuleImpl: ObjectImpl
 where
     <Self as ObjectSubclass>::Type: IsA<TypeModule>,
 {
@@ -24,7 +24,7 @@ where
     fn unload(&self);
 }
 
-pub trait TypeModuleImplExt: ObjectSubclass
+pub trait TypeModuleImplExt: ObjectSubclass + TypeModuleImpl
 where
     <Self as ObjectSubclass>::Type: IsA<TypeModule>,
 {
diff --git a/glib/src/subclass/type_plugin.rs b/glib/src/subclass/type_plugin.rs
index 9700225d01b0..9e8ab6908b0a 100644
--- a/glib/src/subclass/type_plugin.rs
+++ b/glib/src/subclass/type_plugin.rs
@@ -6,7 +6,7 @@ use crate::{
     Type, TypeFlags, TypeInfo, TypePlugin, TypeValueTable,
 };
 
-pub trait TypePluginImpl: ObjectImpl + TypePluginImplExt
+pub trait TypePluginImpl: ObjectImpl
 where
     <Self as ObjectSubclass>::Type: IsA<TypePlugin>,
 {
@@ -27,7 +27,7 @@ where
     }
 }
 
-pub trait TypePluginImplExt: ObjectSubclass
+pub trait TypePluginImplExt: ObjectSubclass + TypePluginImpl
 where
     <Self as ObjectSubclass>::Type: IsA<TypePlugin>,
 {