subclass trial 2

Author: youknowone

crates/derive-impl/src/pyclass.rs

@@ -397,22 +397,34 @@ fn generate_class_def(
         quote! { ::rustpython_vm::builtins::PyBaseObject }
     };
 
-    // Generate PySubclass impl for types with:
-    // - base class specified
-    // - #[repr(transparent)] (required for safe transmute)
-    // - not PyStructSequence
+    // Generate PySubclass impl for #[repr(transparent)] types with base class
+    // (tuple struct assumed, so &self.0 works)
     let subclass_impl = if !is_pystruct && is_repr_transparent {
         base.as_ref().map(|typ| {
             quote! {
                 impl ::rustpython_vm::class::PySubclass for #ident {
                     type Base = #typ;
+
+                    #[inline]
+                    fn as_base(&self) -> &Self::Base {
+                        &self.0
+                    }
                 }
             }
         })
     } else {
         None
     };
 
+    // Generate PySubclassTransparent marker for #[repr(transparent)] types
+    let transparent_impl = if !is_pystruct && is_repr_transparent && base.is_some() {
+        Some(quote! {
+            impl ::rustpython_vm::class::PySubclassTransparent for #ident {}
+        })
+    } else {
+        None
+    };
+
     let tokens = quote! {
         impl ::rustpython_vm::class::PyClassDef for #ident {
             const NAME: &'static str = #name;
@@ -439,6 +451,7 @@ fn generate_class_def(
         }
 
         #subclass_impl
+        #transparent_impl
     };
     Ok(tokens)
 }

crates/vm/src/builtins/bool.rs

@@ -107,7 +107,11 @@ impl PyPayload for PyBool {
         ) -> PyBaseExceptionRef {
             vm.new_downcast_type_error(class, obj)
         }
-        Err(raise_downcast_type_error(vm, Self::class(&vm.ctx), obj))
+        Err(crate::object::cold_downcast_type_error(
+            vm,
+            Self::class(&vm.ctx),
+            obj,
+        ))
     }
 }
 

crates/vm/src/builtins/int.rs

@@ -256,7 +256,7 @@ impl PyInt {
             Ok(vm
                 .ctx
                 .new_bool(!value.into().eq(&BigInt::zero()))
-                .into_base())
+                .into_base_ref())
         } else {
             Self::from(value).into_ref_with_type(vm, cls)
         }

crates/vm/src/class.rs

@@ -173,17 +173,30 @@ pub trait PyClassImpl: PyClassDef {
     }
 }
 
-/// Marker trait for Python subclasses with `#[repr(transparent)]` newtype pattern.
+/// Trait for Python subclasses that can provide a reference to their base type.
 ///
 /// This trait is automatically implemented by the `#[pyclass]` macro when
-/// `base = SomeType` is specified. It enables type-safe conversion between
-/// `PyRef<Subclass>` and `PyRef<Base>`.
+/// `base = SomeType` is specified. It provides safe reference access to the
+/// base type's payload.
+///
+/// For subclasses with `#[repr(transparent)]`, see also [`PySubclassTransparent`]
+/// which enables ownership transfer via `into_base()`.
+pub trait PySubclass: crate::PyPayload {
+    type Base: crate::PyPayload;
+
+    /// Returns a reference to the base type's payload.
+    fn as_base(&self) -> &Self::Base;
+}
+
+/// Marker trait for `#[repr(transparent)]` subclasses.
+///
+/// This trait enables ownership transfer from `PyRef<Self>` to `PyRef<Self::Base>`
+/// via the `into_base_ref()` method. Only types with identical memory layout to their
+/// base type (i.e., `#[repr(transparent)]` newtypes) should implement this trait.
 ///
 /// # Safety
 ///
 /// Implementors must ensure:
 /// - The type uses `#[repr(transparent)]` with the Base type as the only field
 /// - Memory layout is identical to the Base type
-pub trait PySubclass: crate::PyPayload {
-    type Base: crate::PyPayload;
-}
+pub trait PySubclassTransparent: PySubclass {}

crates/vm/src/object/core.rs

@@ -1081,18 +1081,29 @@ impl<T: PyObjectPayload> PyRef<T> {
 }
 
 impl<T: crate::class::PySubclass> PyRef<T> {
-    /// Converts this reference to a reference of the base type.
+    /// Returns a reference to the base type's payload.
+    #[inline]
+    pub fn as_base(&self) -> &T::Base {
+        (**self).as_base()
+    }
+}
+
+impl<T: crate::class::PySubclassTransparent> PyRef<T> {
+    /// Converts this reference to the base type (ownership transfer).
     ///
-    /// This is safe because T has `#[repr(transparent)]` layout with T::Base.
+    /// Only available for `#[repr(transparent)]` types where memory layout
+    /// is identical to the base type.
     #[inline]
-    pub fn into_base(self) -> PyRef<T::Base> {
+    pub fn into_base_ref(self) -> PyRef<T::Base> {
         // SAFETY: #[repr(transparent)] guarantees same memory layout
         unsafe { std::mem::transmute(self) }
     }
 
-    /// Returns a reference to the base type.
+    /// Returns a reference to this as a PyRef of the base type.
+    ///
+    /// Only available for `#[repr(transparent)]` types.
     #[inline]
-    pub fn as_base(&self) -> &PyRef<T::Base> {
+    pub fn as_base_ref(&self) -> &PyRef<T::Base> {
         // SAFETY: #[repr(transparent)] guarantees same memory layout
         unsafe { std::mem::transmute(self) }
     }

crates/vm/src/object/mod.rs

@@ -8,3 +8,5 @@ pub use self::core::*;
 pub use self::ext::*;
 pub use self::payload::*;
 pub use traverse::{MaybeTraverse, Traverse, TraverseFn};
+
+pub(crate) use self::payload::cold_downcast_type_error;

crates/vm/src/object/payload.rs

@@ -16,6 +16,15 @@ cfg_if::cfg_if! {
     }
 }
 
+#[cold]
+pub(crate) fn cold_downcast_type_error(
+    vm: &VirtualMachine,
+    class: &Py<PyType>,
+    obj: &PyObject,
+) -> PyBaseExceptionRef {
+    vm.new_downcast_type_error(class, obj)
+}
+
 pub trait PyPayload:
     std::fmt::Debug + MaybeTraverse + PyThreadingConstraint + Sized + 'static
 {
@@ -35,17 +44,8 @@ pub trait PyPayload:
             return Ok(());
         }
 
-        #[cold]
-        fn raise_downcast_type_error(
-            vm: &VirtualMachine,
-            class: &Py<PyType>,
-            obj: &PyObject,
-        ) -> PyBaseExceptionRef {
-            vm.new_downcast_type_error(class, obj)
-        }
-
         let class = Self::class(&vm.ctx);
-        Err(raise_downcast_type_error(vm, class, obj))
+        Err(cold_downcast_type_error(vm, class, obj))
     }
 
     fn class(ctx: &Context) -> &'static Py<PyType>;