Merge pull request RustPython#548 from rickyhan/new_vm_fns

Move set_item to DictProtocol

Author: windelbouwman

parser/src/parser.rs

@@ -306,7 +306,9 @@ mod tests {
 
     #[test]
     fn test_parse_class() {
-        let source = String::from("class Foo(A, B):\n def __init__(self):\n  pass\n def method_with_default(self, arg='default'):\n  pass\n");
+        let source = String::from(
+            "class Foo(A, B):\n def __init__(self):\n  pass\n def method_with_default(self, arg='default'):\n  pass\n",
+        );
         assert_eq!(
             parse_statement(&source),
             Ok(ast::LocatedStatement {

vm/src/compile.rs

@@ -1389,7 +1389,7 @@ impl Compiler {
     // Low level helper functions:
     fn emit(&mut self, instruction: Instruction) {
         let location = self.current_source_location.clone();
-        let mut cur_code_obj = self.current_code_object();
+        let cur_code_obj = self.current_code_object();
         cur_code_obj.instructions.push(instruction);
         cur_code_obj.locations.push(location);
         // TODO: insert source filename

vm/src/import.rs

@@ -60,7 +60,7 @@ pub fn import_module(
         return Ok(module);
     }
     let module = import_uncached_module(vm, current_path, module_name)?;
-    vm.ctx.set_item(&sys_modules, module_name, module.clone());
+    sys_modules.set_item(&vm.ctx, module_name, module.clone());
     Ok(module)
 }
 

vm/src/obj/objobject.rs

@@ -1,8 +1,8 @@
 use super::objstr;
 use super::objtype;
 use crate::pyobject::{
-    AttributeProtocol, IdProtocol, PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef,
-    PyResult, TypeProtocol,
+    AttributeProtocol, DictProtocol, IdProtocol, PyContext, PyFuncArgs, PyObject, PyObjectPayload,
+    PyObjectRef, PyResult, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use std::cell::RefCell;
@@ -182,7 +182,7 @@ fn object_dict(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         PyObjectPayload::Class { ref dict, .. } | PyObjectPayload::Instance { ref dict, .. } => {
             let new_dict = vm.new_dict();
             for (attr, value) in dict.borrow().iter() {
-                vm.ctx.set_item(&new_dict, &attr, value.clone());
+                new_dict.set_item(&vm.ctx, &attr, value.clone());
             }
             Ok(new_dict)
         }

vm/src/pyobject.rs

@@ -833,6 +833,7 @@ pub trait DictProtocol {
     fn contains_key(&self, k: &str) -> bool;
     fn get_item(&self, k: &str) -> Option<PyObjectRef>;
     fn get_key_value_pairs(&self) -> Vec<(PyObjectRef, PyObjectRef)>;
+    fn set_item(&self, ctx: &PyContext, key: &str, v: PyObjectRef);
 }
 
 impl DictProtocol for PyObjectRef {
@@ -851,8 +852,9 @@ impl DictProtocol for PyObjectRef {
             PyObjectPayload::Dict { ref elements } => {
                 objdict::content_get_key_str(&elements.borrow(), k)
             }
+            PyObjectPayload::Module { ref dict, .. } => dict.get_item(k),
             PyObjectPayload::Scope { ref scope } => scope.borrow().locals.get_item(k),
-            _ => panic!("TODO"),
+            ref k => panic!("TODO {:?}", k),
         }
     }
 
@@ -864,6 +866,23 @@ impl DictProtocol for PyObjectRef {
             _ => panic!("TODO"),
         }
     }
+
+    // Item set/get:
+    fn set_item(&self, ctx: &PyContext, key: &str, v: PyObjectRef) {
+        match &self.payload {
+            PyObjectPayload::Dict { elements } => {
+                let key = ctx.new_str(key.to_string());
+                objdict::set_item_in_content(&mut elements.borrow_mut(), &key, &v);
+            }
+            PyObjectPayload::Module { dict, .. } => {
+                dict.set_item(ctx, key, v);
+            }
+            PyObjectPayload::Scope { scope, .. } => {
+                scope.borrow().locals.set_item(ctx, key, v);
+            }
+            ref k => panic!("TODO {:?}", k),
+        };
+    }
 }
 
 pub trait BufferProtocol {

vm/src/stdlib/json.rs

@@ -171,7 +171,7 @@ impl<'de> Visitor<'de> for PyObjectDeserializer<'de> {
                 PyObjectPayload::String { ref value } => value.clone(),
                 _ => unimplemented!("map keys must be strings"),
             };
-            self.vm.ctx.set_item(&dict, &key, value);
+            dict.set_item(&self.vm.ctx, &key, value);
         }
         Ok(dict)
     }

vm/src/sysmodule.rs

@@ -1,4 +1,4 @@
-use crate::pyobject::{PyContext, PyFuncArgs, PyObjectRef, PyResult, TypeProtocol};
+use crate::pyobject::{DictProtocol, PyContext, PyFuncArgs, PyObjectRef, PyResult, TypeProtocol};
 use crate::vm::VirtualMachine;
 use std::rc::Rc;
 use std::{env, mem};
@@ -132,7 +132,7 @@ settrace() -- set the global debug tracing function
       "_getframe" => ctx.new_rustfunc(getframe),
     });
 
-    ctx.set_item(&modules, sys_name, sys_mod.clone());
+    modules.set_item(&ctx, sys_name, sys_mod.clone());
     ctx.set_attr(&sys_mod, "modules", modules);
 
     sys_mod

vm/src/vm.rs

@@ -26,6 +26,7 @@ use crate::pyobject::{
 };
 use crate::stdlib;
 use crate::sysmodule;
+use num_bigint::ToBigInt;
 
 // use objects::objects;
 
@@ -53,7 +54,7 @@ impl VirtualMachine {
 
         // Add builtins as builtins module:
         let modules = sysmod.get_attr("modules").unwrap();
-        ctx.set_item(&modules, "builtins", builtins.clone());
+        modules.set_item(&ctx, "builtins", builtins.clone());
 
         let stdlib_inits = stdlib::get_module_inits();
         VirtualMachine {
@@ -76,6 +77,11 @@ impl VirtualMachine {
         self.ctx.new_str(s)
     }
 
+    /// Create a new python int object.
+    pub fn new_int<T: ToBigInt>(&self, i: T) -> PyObjectRef {
+        self.ctx.new_int(i)
+    }
+
     /// Create a new python bool object.
     pub fn new_bool(&self, b: bool) -> PyObjectRef {
         self.ctx.new_bool(b)
@@ -395,7 +401,7 @@ impl VirtualMachine {
 
                 self.ctx.set_attr(scope, &name, value);
             } else if let Some(d) = &kwargs {
-                self.ctx.set_item(d, &name, value);
+                d.set_item(&self.ctx, &name, value);
             } else {
                 return Err(
                     self.new_type_error(format!("Got an unexpected keyword argument '{}'", name))

wasm/lib/src/convert.rs

@@ -1,7 +1,7 @@
 use crate::vm_class::{AccessibleVM, WASMVirtualMachine};
 use js_sys::{Array, ArrayBuffer, Object, Reflect, Uint8Array};
 use rustpython_vm::obj::{objbytes, objtype};
-use rustpython_vm::pyobject::{self, PyFuncArgs, PyObjectRef, PyResult};
+use rustpython_vm::pyobject::{self, DictProtocol, PyFuncArgs, PyObjectRef, PyResult};
 use rustpython_vm::VirtualMachine;
 use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
 
@@ -134,8 +134,7 @@ pub fn js_to_py(vm: &mut VirtualMachine, js_val: JsValue) -> PyObjectRef {
             for pair in object_entries(&Object::from(js_val)) {
                 let (key, val) = pair.expect("iteration over object to not fail");
                 let py_val = js_to_py(vm, val);
-                vm.ctx
-                    .set_item(&dict, &String::from(js_sys::JsString::from(key)), py_val);
+                dict.set_item(&vm.ctx, &String::from(js_sys::JsString::from(key)), py_val);
             }
             dict
         }