Add classmethod and staticmethod classes.

Author: windelbouwman

tests/snippets/class.py

@@ -13,3 +13,26 @@ def square(self):
 assert foo.y == Foo.y
 assert foo.x == 5
 assert foo.square() == 25
+
+
+class Bar:
+    @classmethod
+    def fubar(cls, x):
+        assert cls is Bar
+        assert x == 2
+
+    @staticmethod
+    def kungfu(x):
+        assert x == 3
+
+
+bar = Bar()
+bar.fubar(2)
+
+# TODO: make below work:
+# Bar.fubar(2)
+
+bar.kungfu(3)
+# TODO: make below work:
+# Bar.kungfu(3)
+

vm/src/builtins.rs

@@ -522,7 +522,6 @@ fn builtin_setattr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 // builtin_slice
 // builtin_sorted
-// builtin_staticmethod
 
 fn builtin_sum(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(iterable, None)]);
@@ -557,6 +556,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("bytearray"), ctx.bytearray_type());
     dict.insert(String::from("bytes"), ctx.bytes_type());
     dict.insert(String::from("chr"), ctx.new_rustfunc(builtin_chr));
+    dict.insert(String::from("classmethod"), ctx.classmethod_type());
     dict.insert(String::from("compile"), ctx.new_rustfunc(builtin_compile));
     dict.insert(String::from("complex"), ctx.complex_type());
     dict.insert(String::from("delattr"), ctx.new_rustfunc(builtin_delattr));
@@ -597,6 +597,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("repr"), ctx.new_rustfunc(builtin_repr));
     dict.insert(String::from("set"), ctx.set_type());
     dict.insert(String::from("setattr"), ctx.new_rustfunc(builtin_setattr));
+    dict.insert(String::from("staticmethod"), ctx.staticmethod_type());
     dict.insert(String::from("str"), ctx.str_type());
     dict.insert(String::from("sum"), ctx.new_rustfunc(builtin_sum));
     dict.insert(String::from("tuple"), ctx.tuple_type());
@@ -681,13 +682,13 @@ pub fn builtin_build_class_(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> Py
         },
     )?;
 
-    &vm.invoke(
+    vm.invoke(
         function,
         PyFuncArgs {
             args: vec![namespace.clone()],
             kwargs: vec![],
         },
-    );
+    )?;
 
     vm.call_method(&metaclass, "__call__", vec![name_arg, bases, namespace])
 }

vm/src/obj/objfunction.rs

@@ -1,12 +1,24 @@
-use super::super::pyobject::{AttributeProtocol, PyContext, PyFuncArgs, PyResult};
+use super::super::pyobject::{
+    AttributeProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult,
+    TypeProtocol,
+};
 use super::super::vm::VirtualMachine;
+use super::objtype;
 
 pub fn init(context: &PyContext) {
     let ref function_type = context.function_type;
     function_type.set_attr("__get__", context.new_rustfunc(bind_method));
 
     let ref member_descriptor_type = context.member_descriptor_type;
     member_descriptor_type.set_attr("__get__", context.new_rustfunc(member_get));
+
+    let ref classmethod_type = context.classmethod_type;
+    classmethod_type.set_attr("__get__", context.new_rustfunc(classmethod_get));
+    classmethod_type.set_attr("__new__", context.new_rustfunc(classmethod_new));
+
+    let ref staticmethod_type = context.staticmethod_type;
+    staticmethod_type.set_attr("__get__", context.new_rustfunc(staticmethod_get));
+    staticmethod_type.set_attr("__new__", context.new_rustfunc(staticmethod_new));
 }
 
 fn bind_method(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -22,3 +34,83 @@ fn member_get(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
         }
     }
 }
+
+// Classmethod type methods:
+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.new_bound_method(function, py_obj);
+            Ok(py_method)
+        }
+        None => {
+            let attribute_error = vm.context().exceptions.attribute_error.clone();
+            Err(vm.new_exception(
+                attribute_error,
+                String::from("Attribute Error: classmethod must have 'function' attribute"),
+            ))
+        }
+    }
+}
+
+fn classmethod_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    trace!("classmethod.__new__ {:?}", args.args);
+    arg_check!(vm, args, required = [(cls, None), (callable, None)]);
+
+    let py_obj = PyObject::new(
+        PyObjectKind::Instance {
+            dict: vm.ctx.new_dict(),
+        },
+        cls.clone(),
+    );
+    py_obj.set_attr("function", callable.clone());
+    Ok(py_obj)
+}
+
+// `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 => {
+            let attribute_error = vm.context().exceptions.attribute_error.clone();
+            Err(vm.new_exception(
+                attribute_error,
+                String::from("Attribute Error: staticmethod must have 'function' attribute"),
+            ))
+        }
+    }
+}
+
+fn staticmethod_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    trace!("staticmethod.__new__ {:?}", args.args);
+    arg_check!(vm, args, required = [(cls, None), (callable, None)]);
+
+    let py_obj = PyObject::new(
+        PyObjectKind::Instance {
+            dict: vm.ctx.new_dict(),
+        },
+        cls.clone(),
+    );
+    py_obj.set_attr("function", callable.clone());
+    Ok(py_obj)
+}

vm/src/pyobject.rs

@@ -72,6 +72,8 @@ impl fmt::Display for PyObjectRef {
 pub struct PyContext {
     pub type_type: PyObjectRef,
     pub none: PyObjectRef,
+    pub classmethod_type: PyObjectRef,
+    pub staticmethod_type: PyObjectRef,
     pub dict_type: PyObjectRef,
     pub int_type: PyObjectRef,
     pub float_type: PyObjectRef,
@@ -140,6 +142,8 @@ impl PyContext {
         objdict::create_type(type_type.clone(), object_type.clone(), dict_type.clone());
 
         let module_type = create_type("module", &type_type, &object_type, &dict_type);
+        let classmethod_type = create_type("classmethod", &type_type, &object_type, &dict_type);
+        let staticmethod_type = create_type("staticmethod", &type_type, &object_type, &dict_type);
         let function_type = create_type("function", &type_type, &object_type, &dict_type);
         let generator_type = create_type("generator", &type_type, &object_type, &dict_type);
         let bound_method_type = create_type("method", &type_type, &object_type, &dict_type);
@@ -177,6 +181,8 @@ impl PyContext {
             int_type: int_type,
             float_type: float_type,
             complex_type: complex_type,
+            classmethod_type: classmethod_type,
+            staticmethod_type: staticmethod_type,
             bytes_type: bytes_type,
             bytearray_type: bytearray_type,
             list_type: list_type,
@@ -250,22 +256,35 @@ impl PyContext {
     pub fn bool_type(&self) -> PyObjectRef {
         self.bool_type.clone()
     }
+
     pub fn tuple_type(&self) -> PyObjectRef {
         self.tuple_type.clone()
     }
+
     pub fn iter_type(&self) -> PyObjectRef {
         self.iter_type.clone()
     }
+
     pub fn dict_type(&self) -> PyObjectRef {
         self.dict_type.clone()
     }
+
     pub fn str_type(&self) -> PyObjectRef {
         self.str_type.clone()
     }
+
     pub fn function_type(&self) -> PyObjectRef {
         self.function_type.clone()
     }
 
+    pub fn classmethod_type(&self) -> PyObjectRef {
+        self.classmethod_type.clone()
+    }
+
+    pub fn staticmethod_type(&self) -> PyObjectRef {
+        self.staticmethod_type.clone()
+    }
+
     pub fn generator_type(&self) -> PyObjectRef {
         self.generator_type.clone()
     }