Make PyObject.dict an Option<RefCell<PyDictRef>>

Author: coolreader18

Lib/_threading_local.py

@@ -193,6 +193,7 @@ def thread_deleted(_, idt=idt):
 
 @contextmanager
 def _patch(self):
+    old = object.__getattribute__(self, '__dict__')
     impl = object.__getattribute__(self, '_local__impl')
     try:
         dct = impl.get_dict()
@@ -203,6 +204,7 @@ def _patch(self):
     with impl.locallock:
         object.__setattr__(self, '__dict__', dct)
         yield
+        object.__setattr__(self, '__dict__', old)
 
 
 class local:

vm/src/builtins.rs

@@ -252,9 +252,15 @@ fn make_scope(vm: &VirtualMachine, scope: ScopeArgs) -> PyResult<Scope> {
     let globals = match globals {
         Some(dict) => {
             if !dict.contains_key("__builtins__", vm) {
-                let builtins_dict = vm.builtins.dict.as_ref().unwrap().as_object();
-                dict.set_item("__builtins__", builtins_dict.clone(), vm)
-                    .unwrap();
+                let builtins_dict = vm
+                    .builtins
+                    .dict
+                    .as_ref()
+                    .unwrap()
+                    .borrow()
+                    .as_object()
+                    .clone();
+                dict.set_item("__builtins__", builtins_dict, vm).unwrap();
             }
             dict
         }

vm/src/frame.rs

@@ -699,7 +699,7 @@ impl Frame {
 
         // Grab all the names from the module and put them in the context
         if let Some(dict) = &module.dict {
-            for (k, v) in dict {
+            for (k, v) in &*dict.borrow() {
                 let k = vm.to_str(&k)?;
                 let k = k.as_str();
                 if !k.starts_with('_') {

vm/src/obj/objmodule.rs

@@ -50,7 +50,7 @@ impl PyModuleRef {
         let zelf = PyModule {}.into_ref_with_type(vm, cls)?;
         init_module_dict(
             vm,
-            zelf.as_object().dict.as_ref().unwrap(),
+            &zelf.as_object().dict.as_ref().unwrap().borrow(),
             name.into_object(),
             doc.flat_option()
                 .map_or_else(|| vm.get_none(), PyRef::into_object),

vm/src/obj/objobject.rs

@@ -77,7 +77,7 @@ fn object_setattr(
     }
 
     if let Some(ref dict) = obj.clone().dict {
-        dict.set_item(attr_name.as_str(), value, vm)?;
+        dict.borrow().set_item(attr_name.as_str(), value, vm)?;
         Ok(())
     } else {
         Err(vm.new_attribute_error(format!(
@@ -98,7 +98,7 @@ fn object_delattr(obj: PyObjectRef, attr_name: PyStringRef, vm: &VirtualMachine)
     }
 
     if let Some(ref dict) = obj.dict {
-        dict.del_item(attr_name.as_str(), vm)?;
+        dict.borrow().del_item(attr_name.as_str(), vm)?;
         Ok(())
     } else {
         Err(vm.new_attribute_error(format!(
@@ -130,7 +130,7 @@ pub fn object_dir(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyList> {
     if let Some(object_dict) = &obj.dict {
         vm.invoke(
             &vm.get_attribute(dict.clone().into_object(), "update")?,
-            object_dict.clone().into_object(),
+            object_dict.borrow().clone().into_object(),
         )?;
     }
 
@@ -210,20 +210,22 @@ fn object_class_setter(
 
 fn object_dict(object: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyDictRef> {
     if let Some(ref dict) = object.dict {
-        Ok(dict.clone())
+        Ok(dict.borrow().clone())
     } else {
         Err(vm.new_attribute_error("no dictionary.".to_string()))
     }
 }
 
-fn object_dict_setter(
-    _instance: PyObjectRef,
-    _value: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult {
-    Err(vm.new_not_implemented_error(
-        "Setting __dict__ attribute on an object isn't yet implemented".to_string(),
-    ))
+fn object_dict_setter(instance: PyObjectRef, value: PyDictRef, vm: &VirtualMachine) -> PyResult {
+    if let Some(dict) = &instance.dict {
+        *dict.borrow_mut() = value;
+        Ok(vm.get_none())
+    } else {
+        Err(vm.new_attribute_error(format!(
+            "'{}' object has no attribute '__dict__'",
+            instance.class().name
+        )))
+    }
 }
 
 fn object_getattribute(obj: PyObjectRef, name: PyStringRef, vm: &VirtualMachine) -> PyResult {

vm/src/pyobject.rs

@@ -1,5 +1,5 @@
 use std::any::Any;
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::fmt;
 use std::marker::PhantomData;
@@ -522,7 +522,7 @@ impl PyContext {
     pub fn new_instance(&self, class: PyClassRef, dict: Option<PyDictRef>) -> PyObjectRef {
         PyObject {
             typ: class,
-            dict,
+            dict: dict.map(RefCell::new),
             payload: objobject::PyInstance,
         }
         .into_ref()
@@ -566,7 +566,7 @@ where
     T: ?Sized + PyObjectPayload,
 {
     pub typ: PyClassRef,
-    pub dict: Option<PyDictRef>, // __dict__ member
+    pub dict: Option<RefCell<PyDictRef>>, // __dict__ member
     pub payload: T,
 }
 
@@ -1038,7 +1038,12 @@ where
 {
     #[allow(clippy::new_ret_no_self)]
     pub fn new(payload: T, typ: PyClassRef, dict: Option<PyDictRef>) -> PyObjectRef {
-        PyObject { typ, dict, payload }.into_ref()
+        PyObject {
+            typ,
+            dict: dict.map(RefCell::new),
+            payload,
+        }
+        .into_ref()
     }
 
     // Move this object into a reference object, transferring ownership.

vm/src/vm.rs

@@ -952,7 +952,7 @@ impl VirtualMachine {
         }
 
         let attr = if let Some(ref dict) = obj.dict {
-            dict.get_item_option(name_str.as_str(), self)?
+            dict.borrow().get_item_option(name_str.as_str(), self)?
         } else {
             None
         };