Classmethod/staticmethod - rewrite using structs and new style methods.

Author: cthulahoops

vm/src/obj/objclassmethod.rs

@@ -1,43 +1,42 @@
-use crate::function::PyFuncArgs;
-use crate::pyobject::{AttributeProtocol, PyContext, PyResult, TypeProtocol};
+use super::objtype::PyClassRef;
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
-pub fn init(context: &PyContext) {
-    let classmethod_type = &context.classmethod_type;
-    extend_class!(context, classmethod_type, {
-        "__get__" => context.new_rustfunc(classmethod_get),
-        "__new__" => context.new_rustfunc(classmethod_new)
-    });
+#[derive(Clone, Debug)]
+pub struct PyClassMethod {
+    pub callable: PyObjectRef,
 }
+pub type PyClassMethodRef = PyRef<PyClassMethod>;
 
-fn classmethod_get(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    trace!("classmethod.__get__ {:?}", args.args);
-    arg_check!(
-        vm,
-        args,
-        required = [
-            (cls, Some(vm.ctx.classmethod_type())),
-            (_inst, None),
-            (owner, None)
-        ]
-    );
-    match cls.get_attr("function") {
-        Some(function) => {
-            let py_obj = owner.clone();
-            let py_method = vm.ctx.new_bound_method(function, py_obj);
-            Ok(py_method)
-        }
-        None => Err(vm.new_attribute_error(
-            "Attribute Error: classmethod must have 'function' attribute".to_string(),
-        )),
+impl PyValue for PyClassMethod {
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.classmethod_type()
     }
 }
 
-fn classmethod_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    trace!("classmethod.__new__ {:?}", args.args);
-    arg_check!(vm, args, required = [(cls, None), (callable, None)]);
+impl PyClassMethodRef {
+    fn new(
+        cls: PyClassRef,
+        callable: PyObjectRef,
+        vm: &mut VirtualMachine,
+    ) -> PyResult<PyClassMethodRef> {
+        PyClassMethod {
+            callable: callable.clone(),
+        }
+        .into_ref_with_type(vm, cls)
+    }
+
+    fn get(self, _inst: PyObjectRef, owner: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
+        Ok(vm
+            .ctx
+            .new_bound_method(self.callable.clone(), owner.clone()))
+    }
+}
 
-    let py_obj = vm.ctx.new_instance(cls.clone(), None);
-    vm.ctx.set_attr(&py_obj, "function", callable.clone());
-    Ok(py_obj)
+pub fn init(context: &PyContext) {
+    let classmethod_type = &context.classmethod_type;
+    extend_class!(context, classmethod_type, {
+        "__get__" => context.new_rustfunc(PyClassMethodRef::get),
+        "__new__" => context.new_rustfunc(PyClassMethodRef::new)
+    });
 }

vm/src/obj/objstaticmethod.rs

@@ -1,40 +1,40 @@
-use crate::function::PyFuncArgs;
-use crate::pyobject::{AttributeProtocol, PyContext, PyResult, TypeProtocol};
+use super::objtype::PyClassRef;
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
-pub fn init(context: &PyContext) {
-    let staticmethod_type = &context.staticmethod_type;
-    extend_class!(context, staticmethod_type, {
-        "__get__" => context.new_rustfunc(staticmethod_get),
-        "__new__" => context.new_rustfunc(staticmethod_new),
-    });
+#[derive(Clone, Debug)]
+pub struct PyStaticMethod {
+    pub callable: PyObjectRef,
 }
+pub type PyStaticMethodRef = PyRef<PyStaticMethod>;
 
-// `staticmethod` methods.
-fn staticmethod_get(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    trace!("staticmethod.__get__ {:?}", args.args);
-    arg_check!(
-        vm,
-        args,
-        required = [
-            (cls, Some(vm.ctx.staticmethod_type())),
-            (_inst, None),
-            (_owner, None)
-        ]
-    );
-    match cls.get_attr("function") {
-        Some(function) => Ok(function),
-        None => Err(vm.new_attribute_error(
-            "Attribute Error: staticmethod must have 'function' attribute".to_string(),
-        )),
+impl PyValue for PyStaticMethod {
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.staticmethod_type()
     }
 }
 
-fn staticmethod_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    trace!("staticmethod.__new__ {:?}", args.args);
-    arg_check!(vm, args, required = [(cls, None), (callable, None)]);
+impl PyStaticMethodRef {
+    fn new(
+        cls: PyClassRef,
+        callable: PyObjectRef,
+        vm: &mut VirtualMachine,
+    ) -> PyResult<PyStaticMethodRef> {
+        PyStaticMethod {
+            callable: callable.clone(),
+        }
+        .into_ref_with_type(vm, cls)
+    }
+
+    fn get(self, _inst: PyObjectRef, _owner: PyObjectRef, _vm: &mut VirtualMachine) -> PyResult {
+        Ok(self.callable.clone())
+    }
+}
 
-    let py_obj = vm.ctx.new_instance(cls.clone(), None);
-    vm.ctx.set_attr(&py_obj, "function", callable.clone());
-    Ok(py_obj)
+pub fn init(context: &PyContext) {
+    let staticmethod_type = &context.staticmethod_type;
+    extend_class!(context, staticmethod_type, {
+        "__get__" => context.new_rustfunc(PyStaticMethodRef::get),
+        "__new__" => context.new_rustfunc(PyStaticMethodRef::new),
+    });
 }