Merge pull request RustPython#835 from RustPython/coolreader18/weakproxy

Add weakproxy

Author: windelbouwman

tests/snippets/weakrefs.py

@@ -1,4 +1,5 @@
-from _weakref import ref
+from _weakref import ref, proxy
+from testutils import assert_raises
 
 
 class X:
@@ -11,3 +12,17 @@ class X:
 assert callable(b)
 assert b() is a
 
+
+class G:
+    def __init__(self, h):
+        self.h = h
+
+
+g = G(5)
+p = proxy(g)
+
+assert p.h == 5
+
+del g
+
+assert_raises(ReferenceError, lambda: p.h)

vm/src/builtins.rs

@@ -751,6 +751,7 @@ pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
         "NameError" => ctx.exceptions.name_error.clone(),
         "OverflowError" => ctx.exceptions.overflow_error.clone(),
         "RuntimeError" => ctx.exceptions.runtime_error.clone(),
+        "ReferenceError" => ctx.exceptions.reference_error.clone(),
         "NotImplementedError" => ctx.exceptions.not_implemented_error.clone(),
         "TypeError" => ctx.exceptions.type_error.clone(),
         "ValueError" => ctx.exceptions.value_error.clone(),

vm/src/exceptions.rs

@@ -118,6 +118,7 @@ pub struct ExceptionZoo {
     pub os_error: PyClassRef,
     pub overflow_error: PyClassRef,
     pub permission_error: PyClassRef,
+    pub reference_error: PyClassRef,
     pub runtime_error: PyClassRef,
     pub stop_iteration: PyClassRef,
     pub syntax_error: PyClassRef,
@@ -152,6 +153,7 @@ impl ExceptionZoo {
         let name_error = create_type("NameError", &type_type, &exception_type);
         let os_error = create_type("OSError", &type_type, &exception_type);
         let runtime_error = create_type("RuntimeError", &type_type, &exception_type);
+        let reference_error = create_type("ReferenceError", &type_type, &exception_type);
         let stop_iteration = create_type("StopIteration", &type_type, &exception_type);
         let syntax_error = create_type("SyntaxError", &type_type, &exception_type);
         let type_error = create_type("TypeError", &type_type, &exception_type);
@@ -208,6 +210,7 @@ impl ExceptionZoo {
             syntax_warning,
             resource_warning,
             runtime_warning,
+            reference_error,
             user_warning,
         }
     }

vm/src/obj/mod.rs

@@ -34,5 +34,6 @@ pub mod objstr;
 pub mod objsuper;
 pub mod objtuple;
 pub mod objtype;
+pub mod objweakproxy;
 pub mod objweakref;
 pub mod objzip;

vm/src/obj/objweakproxy.rs

@@ -0,0 +1,50 @@
+use super::objweakref::PyWeak;
+use crate::function::OptionalArg;
+use crate::obj::objtype::PyClassRef;
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::vm::VirtualMachine;
+
+#[derive(Debug)]
+pub struct PyWeakProxy {
+    weak: PyWeak,
+}
+
+impl PyValue for PyWeakProxy {
+    fn class(vm: &VirtualMachine) -> PyClassRef {
+        vm.ctx.weakproxy_type()
+    }
+}
+
+pub type PyWeakProxyRef = PyRef<PyWeakProxy>;
+
+impl PyWeakProxyRef {
+    // TODO callbacks
+    fn create(
+        cls: PyClassRef,
+        referent: PyObjectRef,
+        _callback: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        PyWeakProxy {
+            weak: PyWeak::downgrade(&referent),
+        }
+        .into_ref_with_type(vm, cls)
+    }
+
+    fn getattr(self, attr_name: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        match self.weak.upgrade() {
+            Some(obj) => vm.get_attribute(obj, attr_name),
+            None => Err(vm.new_exception(
+                vm.ctx.exceptions.reference_error.clone(),
+                "weakly-referenced object no longer exists".to_string(),
+            )),
+        }
+    }
+}
+
+pub fn init(context: &PyContext) {
+    extend_class!(context, &context.weakproxy_type, {
+        "__new__" => context.new_rustfunc(PyWeakProxyRef::create),
+        "__getattr__" => context.new_rustfunc(PyWeakProxyRef::getattr),
+    });
+}

vm/src/obj/objweakref.rs

@@ -1,9 +1,9 @@
+use crate::function::OptionalArg;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::PyValue;
 use crate::pyobject::{PyContext, PyObject, PyObjectPayload, PyObjectRef, PyRef, PyResult};
 use crate::vm::VirtualMachine;
 
-use crate::function::OptionalArg;
 use std::rc::{Rc, Weak};
 
 #[derive(Debug)]

vm/src/pyobject.rs

@@ -51,6 +51,7 @@ use crate::obj::objstr;
 use crate::obj::objsuper;
 use crate::obj::objtuple::{self, PyTuple, PyTupleRef};
 use crate::obj::objtype::{self, PyClass, PyClassRef};
+use crate::obj::objweakproxy;
 use crate::obj::objweakref;
 use crate::obj::objzip;
 use crate::vm::VirtualMachine;
@@ -158,6 +159,7 @@ pub struct PyContext {
     pub module_type: PyClassRef,
     pub bound_method_type: PyClassRef,
     pub weakref_type: PyClassRef,
+    pub weakproxy_type: PyClassRef,
     pub object: PyClassRef,
     pub exceptions: exceptions::ExceptionZoo,
 }
@@ -255,6 +257,7 @@ impl PyContext {
         let readonly_property_type = create_type("readonly_property", &type_type, &object_type);
         let super_type = create_type("super", &type_type, &object_type);
         let weakref_type = create_type("ref", &type_type, &object_type);
+        let weakproxy_type = create_type("weakproxy", &type_type, &object_type);
         let generator_type = create_type("generator", &type_type, &object_type);
         let bound_method_type = create_type("method", &type_type, &object_type);
         let str_type = create_type("str", &type_type, &object_type);
@@ -361,6 +364,7 @@ impl PyContext {
             module_type,
             bound_method_type,
             weakref_type,
+            weakproxy_type,
             type_type,
             exceptions,
         };
@@ -396,6 +400,7 @@ impl PyContext {
         objcode::init(&context);
         objframe::init(&context);
         objweakref::init(&context);
+        objweakproxy::init(&context);
         objnone::init(&context);
         objmodule::init(&context);
         exceptions::init(&context);
@@ -554,6 +559,10 @@ impl PyContext {
         self.weakref_type.clone()
     }
 
+    pub fn weakproxy_type(&self) -> PyClassRef {
+        self.weakproxy_type.clone()
+    }
+
     pub fn type_type(&self) -> PyClassRef {
         self.type_type.clone()
     }

vm/src/stdlib/weakref.rs

@@ -12,6 +12,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     let ctx = &vm.ctx;
 
     py_module!(vm, "_weakref", {
-        "ref" => ctx.weakref_type()
+        "ref" => ctx.weakref_type(),
+        "proxy" => ctx.weakproxy_type(),
     })
 }