Initial version of property class.

windelbouwman · windelbouwman · commit a389b55ec18f · 2018-11-04T17:14:07.000+01:00
diff --git a/tests/snippets/class.py b/tests/snippets/class.py
@@ -14,6 +14,21 @@ def square(self):
 assert foo.x == 5
 assert foo.square() == 25
 
+class Fubar:
+    def __init__(self):
+        self.x = 100
+
+    @property
+    def foo(self):
+        value = self.x
+        self.x += 1
+        return value
+
+
+f = Fubar()
+assert f.foo == 100
+assert f.foo == 101
+
 
 class Bar:
     @classmethod
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -115,8 +115,6 @@ fn builtin_chr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.new_str(txt))
 }
 
-// builtin_classmethod
-
 fn builtin_compile(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(source, None)]);
     // TODO:
@@ -487,8 +485,6 @@ pub fn builtin_print(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.get_none())
 }
 
-// builtin_property
-
 fn builtin_range(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(range, Some(vm.ctx.int_type()))]);
     match range.borrow().kind {
@@ -593,6 +589,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("next"), ctx.new_rustfunc(builtin_next));
     dict.insert(String::from("pow"), ctx.new_rustfunc(builtin_pow));
     dict.insert(String::from("print"), ctx.new_rustfunc(builtin_print));
+    dict.insert(String::from("property"), ctx.property_type());
     dict.insert(String::from("range"), ctx.new_rustfunc(builtin_range));
     dict.insert(String::from("repr"), ctx.new_rustfunc(builtin_repr));
     dict.insert(String::from("set"), ctx.set_type());
diff --git a/vm/src/obj/mod.rs b/vm/src/obj/mod.rs
@@ -12,6 +12,7 @@ pub mod objint;
 pub mod objiter;
 pub mod objlist;
 pub mod objobject;
+pub mod objproperty;
 pub mod objsequence;
 pub mod objset;
 pub mod objstr;
diff --git a/vm/src/obj/objproperty.rs b/vm/src/obj/objproperty.rs
@@ -0,0 +1,59 @@
+/*! Python `property` descriptor class.
+
+*/
+
+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 property_type = context.property_type;
+    property_type.set_attr("__get__", context.new_rustfunc(property_get));
+    property_type.set_attr("__new__", context.new_rustfunc(property_new));
+    // TODO: how to handle __set__ ?
+}
+
+// `property` methods.
+fn property_get(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    trace!("property.__get__ {:?}", args.args);
+    arg_check!(
+        vm,
+        args,
+        required = [
+            (cls, Some(vm.ctx.property_type())),
+            (inst, None),
+            (_owner, None)
+        ]
+    );
+
+    match cls.get_attr("fget") {
+        Some(getter) => {
+            let py_method = vm.new_bound_method(getter, inst.clone());
+            vm.invoke(py_method, PyFuncArgs::default())
+        }
+        None => {
+            let attribute_error = vm.context().exceptions.attribute_error.clone();
+            Err(vm.new_exception(
+                attribute_error,
+                String::from("Attribute Error: property must have 'fget' attribute"),
+            ))
+        }
+    }
+}
+
+fn property_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    trace!("property.__new__ {:?}", args.args);
+    arg_check!(vm, args, required = [(cls, None), (fget, None)]);
+
+    let py_obj = PyObject::new(
+        PyObjectKind::Instance {
+            dict: vm.ctx.new_dict(),
+        },
+        cls.clone(),
+    );
+    py_obj.set_attr("fget", fget.clone());
+    Ok(py_obj)
+}
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -13,6 +13,7 @@ use super::obj::objint;
 use super::obj::objiter;
 use super::obj::objlist;
 use super::obj::objobject;
+use super::obj::objproperty;
 use super::obj::objset;
 use super::obj::objstr;
 use super::obj::objtuple;
@@ -89,6 +90,7 @@ pub struct PyContext {
     pub iter_type: PyObjectRef,
     pub str_type: PyObjectRef,
     pub function_type: PyObjectRef,
+    pub property_type: PyObjectRef,
     pub generator_type: PyObjectRef,
     pub module_type: PyObjectRef,
     pub bound_method_type: PyObjectRef,
@@ -145,6 +147,7 @@ impl PyContext {
         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 property_type = create_type("property", &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);
         let member_descriptor_type =
@@ -197,6 +200,7 @@ impl PyContext {
             str_type: str_type,
             object: object_type,
             function_type: function_type,
+            property_type: property_type,
             generator_type: generator_type,
             module_type: module_type,
             bound_method_type: bound_method_type,
@@ -217,6 +221,7 @@ impl PyContext {
         objcomplex::init(&context);
         objbytes::init(&context);
         objbytearray::init(&context);
+        objproperty::init(&context);
         objstr::init(&context);
         objtuple::init(&context);
         objiter::init(&context);
@@ -277,6 +282,10 @@ impl PyContext {
         self.function_type.clone()
     }
 
+    pub fn property_type(&self) -> PyObjectRef {
+        self.property_type.clone()
+    }
+
     pub fn classmethod_type(&self) -> PyObjectRef {
         self.classmethod_type.clone()
     }
