allow heap-getset

youknowone · youknowone · commit f57cddf08512 · 2025-06-29T02:32:49.000+09:00
diff --git a/stdlib/src/pyexpat.rs b/stdlib/src/pyexpat.rs
@@ -18,7 +18,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 
 macro_rules! create_property {
     ($ctx: expr, $attributes: expr, $name: expr, $class: expr, $element: ident) => {
-        let attr = $ctx.new_getset(
+        let attr = $ctx.new_static_getset(
             $name,
             $class,
             move |this: &PyExpatLikeXmlParser| this.$element.read().clone(),
diff --git a/vm/src/builtins/getset.rs b/vm/src/builtins/getset.rs
@@ -4,6 +4,7 @@
 use super::PyType;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    builtins::type_::PointerSlot,
     class::PyClassImpl,
     function::{IntoPyGetterFunc, IntoPySetterFunc, PyGetterFunc, PySetterFunc, PySetterValue},
     types::{GetDescriptor, Unconstructible},
@@ -12,7 +13,7 @@ use crate::{
 #[pyclass(module = false, name = "getset_descriptor")]
 pub struct PyGetSet {
     name: String,
-    class: &'static Py<PyType>,
+    class: PointerSlot<Py<PyType>>, // A class type freed before getset is non-sense.
     getter: Option<PyGetterFunc>,
     setter: Option<PySetterFunc>,
     // doc: Option<String>,
@@ -72,7 +73,7 @@ impl PyGetSet {
     pub fn new(name: String, class: &'static Py<PyType>) -> Self {
         Self {
             name,
-            class,
+            class: PointerSlot::from(class),
             getter: None,
             setter: None,
         }
@@ -138,13 +139,17 @@ impl PyGetSet {
 
     #[pygetset]
     fn __qualname__(&self) -> String {
-        format!("{}.{}", self.class.slot_name(), self.name.clone())
+        format!(
+            "{}.{}",
+            unsafe { self.class.borrow_static() }.slot_name(),
+            self.name.clone()
+        )
     }
 
     #[pymember]
     fn __objclass__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
         let zelf: &Py<Self> = zelf.try_to_value(vm)?;
-        Ok(zelf.class.to_owned().into())
+        Ok(unsafe { zelf.class.borrow_static() }.to_owned().into())
     }
 }
 impl Unconstructible for PyGetSet {}
diff --git a/vm/src/builtins/property.rs b/vm/src/builtins/property.rs
@@ -386,7 +386,7 @@ pub(crate) fn init(context: &Context) {
     // This is a bit unfortunate, but this instance attribute overlaps with the
     // class __doc__ string..
     extend_class!(context, context.types.property_type, {
-        "__doc__" => context.new_getset(
+        "__doc__" => context.new_static_getset(
             "__doc__",
             context.types.property_type,
             PyProperty::doc_getter,
diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs
@@ -31,7 +31,7 @@ use crate::{
 };
 use indexmap::{IndexMap, map::Entry};
 use itertools::Itertools;
-use std::{borrow::Borrow, collections::HashSet, fmt, ops::Deref, pin::Pin, ptr::NonNull};
+use std::{borrow::Borrow, collections::HashSet, ops::Deref, pin::Pin, ptr::NonNull};
 
 #[pyclass(module = false, name = "type", traverse = "manual")]
 pub struct PyType {
@@ -69,6 +69,9 @@ pub struct HeapTypeExt {
 
 pub struct PointerSlot<T>(NonNull<T>);
 
+unsafe impl<T> Sync for PointerSlot<T> {}
+unsafe impl<T> Send for PointerSlot<T> {}
+
 impl<T> PointerSlot<T> {
     pub unsafe fn borrow_static(&self) -> &'static T {
         unsafe { self.0.as_ref() }
@@ -126,14 +129,14 @@ unsafe impl Traverse for PyAttributes {
     }
 }
 
-impl fmt::Display for PyType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.name(), f)
+impl std::fmt::Display for PyType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.name(), f)
     }
 }
 
-impl fmt::Debug for PyType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Debug for PyType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "[PyType {}]", &self.name())
     }
 }
@@ -908,7 +911,7 @@ impl Constructor for PyType {
         let __dict__ = identifier!(vm, __dict__);
         attributes.entry(__dict__).or_insert_with(|| {
             vm.ctx
-                .new_getset(
+                .new_static_getset(
                     "__dict__",
                     vm.ctx.types.type_type,
                     subtype_get_dict,
diff --git a/vm/src/class.rs b/vm/src/class.rs
@@ -85,7 +85,7 @@ pub trait PyClassImpl: PyClassDef {
             let __dict__ = identifier!(ctx, __dict__);
             class.set_attr(
                 __dict__,
-                ctx.new_getset(
+                ctx.new_static_getset(
                     "__dict__",
                     class,
                     crate::builtins::object::object_get_dict,
diff --git a/vm/src/vm/context.rs b/vm/src/vm/context.rs
@@ -570,7 +570,7 @@ impl Context {
         PyRef::new_ref(getset, self.types.getset_type.to_owned(), None)
     }
 
-    pub fn new_getset<G, S, T, U>(
+    pub fn new_static_getset<G, S, T, U>(
         &self,
         name: impl Into<String>,
         class: &'static Py<PyType>,
@@ -586,6 +586,26 @@ impl Context {
         PyRef::new_ref(getset, self.types.getset_type.to_owned(), None)
     }
 
+    /// Creates a new `PyGetSet` with a heap type.
+    ///
+    /// # Safety
+    /// In practice, this constructor is safe because a getset is always owned by its `class` type.
+    /// However, it can be broken if used unconventionally.
+    pub unsafe fn new_getset<G, S, T, U>(
+        &self,
+        name: impl Into<String>,
+        class: &Py<PyType>,
+        g: G,
+        s: S,
+    ) -> PyRef<PyGetSet>
+    where
+        G: IntoPyGetterFunc<T>,
+        S: IntoPySetterFunc<U>,
+    {
+        let class = unsafe { &*(class as *const _) };
+        self.new_static_getset(name, class, g, s)
+    }
+
     pub fn new_base_object(&self, class: PyTypeRef, dict: Option<PyDictRef>) -> PyObjectRef {
         debug_assert_eq!(
             class.slots.flags.contains(PyTypeFlags::HAS_DICT),
