slot inheritance

RustPython · youknowone · May 25, 2022 · May 25, 2022 · May 26, 2022 · May 26, 2022
commit cffe5e35938448c871ffa86a7d20aa7f3f2f5ec9
diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs
@@ -95,6 +95,7 @@ impl PyType {
             .map(|x| x.iter_mro().cloned().collect())
             .collect();
         let mro = linearise_mro(mros)?;
+        slots.inherits(&mro);
 
         if base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
             slots.flags |= PyTypeFlags::HAS_DICT
@@ -521,7 +522,7 @@ impl PyType {
         // updated when __slots__ are supported (toggling the flag off if
         // a class has __slots__ defined).
         let flags = PyTypeFlags::heap_type_flags() | PyTypeFlags::HAS_DICT;
-        let slots = PyTypeSlots::from_flags(flags);
+        let slots = PyTypeSlots::with_flags(flags);
 
         let typ = Self::new_verbose_ref(name.as_str(), base, bases, attributes, slots, metatype)
             .map_err(|e| vm.new_type_error(e))?;

diff --git a/vm/src/macros.rs b/vm/src/macros.rs
@@ -17,7 +17,7 @@ macro_rules! py_class {
     ( $ctx:expr, $class_name:expr, $class_base:expr, $flags:expr, { $($name:tt => $value:expr),* $(,)* }) => {
         {
             #[allow(unused_mut)]
-            let mut slots = $crate::types::PyTypeSlots::from_flags($crate::types::PyTypeFlags::DEFAULT | $flags);
+            let mut slots = $crate::types::PyTypeSlots::with_flags($crate::types::PyTypeFlags::DEFAULT | $flags);
             $($crate::py_class!(@extract_slots($ctx, &mut slots, $name, $value));)*
             let py_class = $ctx.new_class(None, $class_name, $class_base, slots);
             $($crate::py_class!(@extract_attrs($ctx, &py_class, $name, $value));)*

diff --git a/vm/src/protocol/sequence.rs b/vm/src/protocol/sequence.rs
@@ -97,7 +97,7 @@ impl PySequence<'_> {
         self.methods.get_or_init(|| {
             let cls = self.obj.class();
             if !cls.is(&vm.ctx.types.dict_type) {
-                if let Some(f) = cls.mro_find_map(|x| x.slots.as_sequence.load()) {
+                if let Some(f) = cls.slots.as_sequence.load() {
                     return f(self.obj, vm);
                 }
             }

diff --git a/vm/src/types/slot.rs b/vm/src/types/slot.rs
@@ -78,12 +78,42 @@ pub struct PyTypeSlots {
 }
 
 impl PyTypeSlots {
-    pub fn from_flags(flags: PyTypeFlags) -> Self {
+    pub fn with_flags(flags: PyTypeFlags) -> Self {
         Self {
             flags,
             ..Default::default()
         }
     }
+
+    pub fn inherits(&mut self, mro: &[PyTypeRef]) {
+        macro_rules! inherit {
+            ($name:ident) => {
+                if self.$name.load().is_none() {
+                    for ty in mro {
+                        if let Some(func) = ty.slots.$name.load() {
+                            self.$name.store(Some(func));
+                            break;
+                        }
+                    }
+                }
+            };
+        }
+        inherit!(as_sequence);
+        inherit!(as_mapping);
+        inherit!(hash);
+        inherit!(call);
+        inherit!(getattro);
+        inherit!(setattro);
+        // inherit!(as_buffer);
+        inherit!(richcompare);
+        inherit!(iter);
+        inherit!(iternext);
+        inherit!(descr_get);
+        inherit!(descr_set);
+        inherit!(init);
+        inherit!(new);
+        inherit!(del);
+    }
 }
 
 impl std::fmt::Debug for PyTypeSlots {