Implement __slots__ with member_descriptor (RustPython#4106)

Author: moreal

Lib/test/test_rlcompleter.py

@@ -93,8 +93,6 @@ def bar(self):
         self.assertEqual(completer.complete('f.b', 0), 'f.bar')
         self.assertEqual(f.calls, 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_uncreated_attr(self):
         # Attributes like properties and slots should be completed even when
         # they haven't been created on an instance

derive/src/pyclass.rs

@@ -24,6 +24,7 @@ enum AttrName {
     Slot,
     Attr,
     ExtendClass,
+    Member,
 }
 
 impl std::fmt::Display for AttrName {
@@ -36,6 +37,7 @@ impl std::fmt::Display for AttrName {
             Self::Slot => "pyslot",
             Self::Attr => "pyattr",
             Self::ExtendClass => "extend_class",
+            Self::Member => "pymember",
         };
         s.fmt(f)
     }
@@ -52,6 +54,7 @@ impl FromStr for AttrName {
             "pyslot" => Self::Slot,
             "pyattr" => Self::Attr,
             "extend_class" => Self::ExtendClass,
+            "pymember" => Self::Member,
             s => {
                 return Err(s.to_owned());
             }
@@ -423,6 +426,11 @@ struct ExtendClassItem {
     inner: ContentItemInner<AttrName>,
 }
 
+/// #[pymember]
+struct MemberItem {
+    inner: ContentItemInner<AttrName>,
+}
+
 impl ContentItem for MethodItem {
     type AttrName = AttrName;
     fn inner(&self) -> &ContentItemInner<AttrName> {
@@ -453,6 +461,12 @@ impl ContentItem for ExtendClassItem {
         &self.inner
     }
 }
+impl ContentItem for MemberItem {
+    type AttrName = AttrName;
+    fn inner(&self) -> &ContentItemInner<AttrName> {
+        &self.inner
+    }
+}
 
 struct ImplItemArgs<'a, Item: ItemLike> {
     item: &'a Item,
@@ -661,6 +675,42 @@ where
     }
 }
 
+impl<Item> ImplItem<Item> for MemberItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        let func = args
+            .item
+            .function_or_method()
+            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
+        let ident = &func.sig().ident;
+
+        let item_attr = args.attrs.remove(self.index());
+        let item_meta = MemberItemMeta::from_attr(ident.clone(), &item_attr)?;
+
+        let py_name = item_meta.member_name()?;
+        let tokens = {
+            quote_spanned! { ident.span() =>
+                class.set_str_attr(
+                    #py_name,
+                    ctx.new_member(#py_name, Self::#ident, class),
+                    ctx,
+                );
+            }
+        };
+
+        args.context.impl_extend_items.add_item(
+            ident.clone(),
+            vec![py_name],
+            args.cfgs.to_vec(),
+            tokens,
+            5,
+        )?;
+        Ok(())
+    }
+}
+
 #[derive(Default)]
 #[allow(clippy::type_complexity)]
 struct GetSetNursery {
@@ -930,6 +980,28 @@ impl SlotItemMeta {
     }
 }
 
+struct MemberItemMeta(ItemMetaInner);
+
+impl ItemMeta for MemberItemMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &["magic"];
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self(inner)
+    }
+    fn inner(&self) -> &ItemMetaInner {
+        &self.0
+    }
+}
+
+impl MemberItemMeta {
+    fn member_name(&self) -> Result<String> {
+        let inner = self.inner();
+        let magic = inner._bool("magic")?;
+        let name = inner.item_name();
+        Ok(if magic { format!("__{}__", name) } else { name })
+    }
+}
+
 struct ExtractedImplAttrs {
     with_impl: TokenStream,
     with_slots: TokenStream,
@@ -1049,6 +1121,9 @@ where
         ExtendClass => Box::new(ExtendClassItem {
             inner: ContentItemInner { index, attr_name },
         }),
+        Member => Box::new(MemberItem {
+            inner: ContentItemInner { index, attr_name },
+        }),
     })
 }
 

derive/src/util.rs

@@ -23,6 +23,7 @@ pub(crate) const ALL_ALLOWED_NAMES: &[&str] = &[
     "pyattr",
     "pyslot",
     "extend_class",
+    "pymember",
 ];
 
 #[derive(Clone)]

vm/src/builtins/descriptor.rs

@@ -0,0 +1,149 @@
+use super::{PyStr, PyType, PyTypeRef};
+use crate::{
+    class::PyClassImpl,
+    types::{Constructor, GetDescriptor, Unconstructible},
+    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+};
+use rustpython_common::lock::PyRwLock;
+
+#[derive(Debug)]
+pub struct DescrObject {
+    pub typ: PyTypeRef,
+    pub name: String,
+    pub qualname: PyRwLock<Option<String>>,
+}
+
+#[derive(Debug)]
+pub enum MemberKind {
+    ObjectEx = 16,
+}
+
+pub enum MemberGetter {
+    Getter(fn(&VirtualMachine, PyObjectRef) -> PyResult),
+    Offset(usize),
+}
+
+pub struct MemberDef {
+    pub name: String,
+    pub kind: MemberKind,
+    pub getter: MemberGetter,
+    pub doc: Option<String>,
+}
+
+impl MemberDef {
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        match self.getter {
+            MemberGetter::Getter(getter) => (getter)(vm, obj),
+            MemberGetter::Offset(offset) => get_slot_from_object(obj, offset, self, vm),
+        }
+    }
+}
+
+impl std::fmt::Debug for MemberDef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MemberDef")
+            .field("name", &self.name)
+            .field("kind", &self.kind)
+            .field("doc", &self.doc)
+            .finish()
+    }
+}
+
+#[pyclass(name = "member_descriptor", module = false)]
+#[derive(Debug)]
+pub struct MemberDescrObject {
+    pub common: DescrObject,
+    pub member: MemberDef,
+}
+
+impl PyPayload for MemberDescrObject {
+    fn class(vm: &VirtualMachine) -> &'static Py<PyType> {
+        vm.ctx.types.member_descriptor_type
+    }
+}
+
+fn calculate_qualname(descr: &DescrObject, vm: &VirtualMachine) -> PyResult<Option<String>> {
+    if let Some(qualname) = vm.get_attribute_opt(descr.typ.to_owned().into(), "__qualname__")? {
+        let str = qualname.downcast::<PyStr>().map_err(|_| {
+            vm.new_type_error(
+                "<descriptor>.__objclass__.__qualname__ is not a unicode object".to_owned(),
+            )
+        })?;
+        Ok(Some(format!("{}.{}", str, descr.name)))
+    } else {
+        Ok(None)
+    }
+}
+
+#[pyclass(with(GetDescriptor, Constructor), flags(BASETYPE))]
+impl MemberDescrObject {
+    #[pymethod(magic)]
+    fn repr(zelf: PyRef<Self>) -> String {
+        format!(
+            "<member '{}' of '{}' objects>",
+            zelf.common.name,
+            zelf.common.typ.name(),
+        )
+    }
+
+    #[pyproperty(magic)]
+    fn doc(zelf: PyRef<Self>) -> Option<String> {
+        zelf.member.doc.to_owned()
+    }
+
+    #[pyproperty(magic)]
+    fn qualname(&self, vm: &VirtualMachine) -> PyResult<Option<String>> {
+        let qualname = self.common.qualname.read();
+        Ok(if qualname.is_none() {
+            drop(qualname);
+            let calculated = calculate_qualname(&self.common, vm)?;
+            *self.common.qualname.write() = calculated.to_owned();
+            calculated
+        } else {
+            qualname.to_owned()
+        })
+    }
+}
+
+// PyMember_GetOne
+fn get_slot_from_object(
+    obj: PyObjectRef,
+    offset: usize,
+    member: &MemberDef,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let slot = match member.kind {
+        MemberKind::ObjectEx => obj.get_slot(offset).ok_or_else(|| {
+            vm.new_attribute_error(format!(
+                "'{}' object has no attribute '{}'",
+                obj.class().name(),
+                member.name
+            ))
+        })?,
+    };
+    Ok(slot)
+}
+
+impl Unconstructible for MemberDescrObject {}
+
+impl GetDescriptor for MemberDescrObject {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match obj {
+            Some(x) => {
+                let zelf = Self::_zelf(zelf, vm)?;
+                zelf.member.get(x, vm)
+            }
+            None => Ok(zelf),
+        }
+    }
+}
+
+pub fn init(context: &Context) {
+    let member_descriptor_type = &context.types.member_descriptor_type;
+    MemberDescrObject::extend_class(context, member_descriptor_type);
+}

vm/src/builtins/function.rs

@@ -5,7 +5,10 @@ use super::{
     tuple::PyTupleTyped, PyAsyncGen, PyCode, PyCoroutine, PyDictRef, PyGenerator, PyStr, PyStrRef,
     PyTupleRef, PyType, PyTypeRef,
 };
+#[cfg(feature = "jit")]
+use crate::common::lock::OnceCell;
 use crate::common::lock::PyMutex;
+use crate::convert::ToPyObject;
 use crate::function::ArgMapping;
 use crate::{
     bytecode,
@@ -16,8 +19,6 @@ use crate::{
     types::{Callable, Comparable, Constructor, GetAttr, GetDescriptor, PyComparisonOp},
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
 };
-#[cfg(feature = "jit")]
-use crate::{common::lock::OnceCell, convert::ToPyObject};
 use itertools::Itertools;
 #[cfg(feature = "jit")]
 use rustpython_jit::CompiledCode;
@@ -352,14 +353,21 @@ impl PyFunction {
         self.defaults_and_kwdefaults.lock().1 = kwdefaults
     }
 
-    #[pyproperty(magic)]
-    fn globals(&self) -> PyDictRef {
-        self.globals.clone()
+    // {"__closure__",   T_OBJECT,     OFF(func_closure), READONLY},
+    // {"__doc__",       T_OBJECT,     OFF(func_doc), 0},
+    // {"__globals__",   T_OBJECT,     OFF(func_globals), READONLY},
+    // {"__module__",    T_OBJECT,     OFF(func_module), 0},
+    // {"__builtins__",  T_OBJECT,     OFF(func_builtins), READONLY},
+    #[pymember(magic)]
+    fn globals(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf = Self::_zelf(zelf, vm)?;
+        Ok(zelf.globals.clone().into())
     }
 
-    #[pyproperty(magic)]
-    fn closure(&self) -> Option<PyTupleTyped<PyCellRef>> {
-        self.closure.clone()
+    #[pymember(magic)]
+    fn closure(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf = Self::_zelf(zelf, vm)?;
+        Ok(vm.unwrap_or_none(zelf.closure.clone().map(|x| x.to_pyobject(vm))))
     }
 
     #[pyproperty(magic)]

vm/src/builtins/mod.rs

@@ -89,6 +89,7 @@ pub use zip::PyZip;
 #[path = "union.rs"]
 pub(crate) mod union_;
 pub use union_::PyUnion;
+pub(crate) mod descriptor;
 
 pub use float::try_to_bigint as try_f64_to_bigint;
 pub use int::try_to_float as try_bigint_to_f64;