Change scope from using set_item to set_attr.

Author: windelbouwman

vm/src/builtins.rs

@@ -213,23 +213,7 @@ fn builtin_eval(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         return Err(vm.new_type_error("code argument must be str or code object".to_string()));
     };
 
-    let locals = if let Some(locals) = locals {
-        locals.clone()
-    } else {
-        vm.new_dict()
-    };
-
-    // TODO: handle optional globals
-    // Construct new scope:
-    let scope_inner = Scope {
-        locals,
-        parent: None,
-    };
-    let scope = PyObject {
-        payload: PyObjectPayload::Scope { scope: scope_inner },
-        typ: None,
-    }
-    .into_ref();
+    let scope = make_scope(vm, locals);
 
     // Run the source:
     vm.run_code_obj(code_obj.clone(), scope)
@@ -266,28 +250,32 @@ fn builtin_exec(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         return Err(vm.new_type_error("source argument must be str or code object".to_string()));
     };
 
+    let scope = make_scope(vm, locals);
+
+    // Run the code:
+    vm.run_code_obj(code_obj, scope)
+}
+
+fn make_scope(vm: &mut VirtualMachine, locals: Option<&PyObjectRef>) -> PyObjectRef {
     // handle optional global and locals
     let locals = if let Some(locals) = locals {
         locals.clone()
     } else {
         vm.new_dict()
     };
 
-    // TODO: use globals
-
+    // TODO: handle optional globals
     // Construct new scope:
     let scope_inner = Scope {
         locals,
         parent: None,
     };
-    let scope = PyObject {
+
+    PyObject {
         payload: PyObjectPayload::Scope { scope: scope_inner },
         typ: None,
     }
-    .into_ref();
-
-    // Run the code:
-    vm.run_code_obj(code_obj, scope)
+    .into_ref()
 }
 
 fn builtin_format(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/frame.rs

@@ -702,7 +702,7 @@ impl Frame {
 
         for (k, v) in obj.get_key_value_pairs().iter() {
             vm.ctx
-                .set_item(&self.locals, &objstr::get_value(k), v.clone());
+                .set_attr(&self.locals, &objstr::get_value(k), v.clone());
         }
         Ok(None)
     }
@@ -829,7 +829,7 @@ impl Frame {
 
     fn store_name(&mut self, vm: &mut VirtualMachine, name: &str) -> FrameResult {
         let obj = self.pop_value();
-        vm.ctx.set_item(&self.locals, name, obj);
+        vm.ctx.set_attr(&self.locals, name, obj);
         Ok(None)
     }
 

vm/src/import.rs

@@ -44,7 +44,7 @@ fn import_uncached_module(
     let builtins = vm.get_builtin_scope();
     let scope = vm.ctx.new_scope(Some(builtins));
     vm.ctx
-        .set_item(&scope, "__name__", vm.new_str(module.to_string()));
+        .set_attr(&scope, "__name__", vm.new_str(module.to_string()));
     vm.run_code_obj(code_obj, scope.clone())?;
     Ok(vm.ctx.new_module(module, scope))
 }

vm/src/obj/objdict.rs

@@ -1,5 +1,6 @@
 use super::super::pyobject::{
-    PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef, PyResult, TypeProtocol,
+    PyAttributes, PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef, PyResult,
+    TypeProtocol,
 };
 use super::super::vm::{ReprGuard, VirtualMachine};
 use super::objiter;
@@ -114,6 +115,25 @@ pub fn content_contains_key_str(elements: &DictContentType, key: &str) -> bool {
     elements.get(key).is_some()
 }
 
+/// Take a python dictionary and convert it to attributes.
+pub fn py_dict_to_attributes(dict: &PyObjectRef) -> PyAttributes {
+    let mut attrs = PyAttributes::new();
+    for (key, value) in get_key_value_pairs(dict) {
+        let key = objstr::get_value(&key);
+        attrs.insert(key, value);
+    }
+    attrs
+}
+
+pub fn attributes_to_py_dict(vm: &mut VirtualMachine, attributes: PyAttributes) -> PyResult {
+    let dict = vm.ctx.new_dict();
+    for (key, value) in attributes {
+        let key = vm.ctx.new_str(key);
+        set_item(&dict, vm, &key, &value);
+    }
+    Ok(dict)
+}
+
 // Python dict methods:
 
 fn dict_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objtype.rs

@@ -126,22 +126,17 @@ pub fn type_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         let mut bases = vm.extract_elements(bases)?;
         bases.push(vm.context().object());
         let name = objstr::get_value(name);
-        new(typ.clone(), &name, bases, py_dict_to_attributes(dict))
+        new(
+            typ.clone(),
+            &name,
+            bases,
+            objdict::py_dict_to_attributes(dict),
+        )
     } else {
         Err(vm.new_type_error(format!(": type_new: {:?}", args)))
     }
 }
 
-/// Take a python dictionary and convert it to attributes.
-fn py_dict_to_attributes(dict: &PyObjectRef) -> PyAttributes {
-    let mut attrs = PyAttributes::new();
-    for (key, value) in objdict::get_key_value_pairs(dict) {
-        let key = objstr::get_value(&key);
-        attrs.insert(key, value);
-    }
-    attrs
-}
-
 pub fn type_call(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     debug!("type_call: {:?}", args);
     let cls = args.shift();

vm/src/pyobject.rs

@@ -158,7 +158,8 @@ pub struct PyContext {
  */
 #[derive(Debug)]
 pub struct Scope {
-    pub locals: PyObjectRef,         // Variables
+    pub locals: PyObjectRef, // Variables
+    // TODO: pub locals: RefCell<PyAttributes>,         // Variables
     pub parent: Option<PyObjectRef>, // Parent scope
 }
 
@@ -645,10 +646,6 @@ impl PyContext {
                 let key = self.new_str(key.to_string());
                 objdict::set_item_in_content(elements, &key, &v);
             }
-            PyObjectPayload::Module { ref mut dict, .. } => self.set_item(dict, key, v),
-            PyObjectPayload::Scope { ref mut scope } => {
-                self.set_item(&scope.locals, key, v);
-            }
             ref k => panic!("TODO {:?}", k),
         };
     }
@@ -662,10 +659,13 @@ impl PyContext {
 
     pub fn set_attr(&self, obj: &PyObjectRef, attr_name: &str, value: PyObjectRef) {
         match obj.borrow().payload {
-            PyObjectPayload::Module { ref dict, .. } => self.set_item(dict, attr_name, value),
+            PyObjectPayload::Module { ref dict, .. } => self.set_attr(dict, attr_name, value),
             PyObjectPayload::Instance { ref dict } | PyObjectPayload::Class { ref dict, .. } => {
                 dict.borrow_mut().insert(attr_name.to_string(), value);
             }
+            PyObjectPayload::Scope { ref scope } => {
+                self.set_item(&scope.locals, attr_name, value);
+            }
             ref payload => unimplemented!("set_attr unimplemented for: {:?}", payload),
         };
     }

vm/src/stdlib/tokenize.rs

@@ -29,7 +29,7 @@ pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
     let py_mod = ctx.new_module("tokenize", ctx.new_scope(None));
 
     // Number theory functions:
-    ctx.set_item(&py_mod, "tokenize", ctx.new_rustfunc(tokenize_tokenize));
+    ctx.set_attr(&py_mod, "tokenize", ctx.new_rustfunc(tokenize_tokenize));
 
     py_mod
 }

vm/src/vm.rs

@@ -340,7 +340,7 @@ impl VirtualMachine {
         for i in 0..n {
             let arg_name = &code_object.arg_names[i];
             let arg = &args.args[i];
-            self.ctx.set_item(scope, arg_name, arg.clone());
+            self.ctx.set_attr(scope, arg_name, arg.clone());
         }
 
         // Pack other positional arguments in to *args:
@@ -354,7 +354,7 @@ impl VirtualMachine {
 
             // If we have a name (not '*' only) then store it:
             if let Some(vararg_name) = vararg {
-                self.ctx.set_item(scope, vararg_name, vararg_value);
+                self.ctx.set_attr(scope, vararg_name, vararg_value);
             }
         } else {
             // Check the number of positional arguments
@@ -372,7 +372,7 @@ impl VirtualMachine {
 
             // Store when we have a name:
             if let Some(kwargs_name) = kwargs {
-                self.ctx.set_item(scope, &kwargs_name, d.clone());
+                self.ctx.set_attr(scope, &kwargs_name, d.clone());
             }
 
             Some(d)
@@ -391,7 +391,7 @@ impl VirtualMachine {
                     );
                 }
 
-                self.ctx.set_item(scope, &name, value);
+                self.ctx.set_attr(scope, &name, value);
             } else if let Some(d) = &kwargs {
                 self.ctx.set_item(d, &name, value);
             } else {
@@ -434,7 +434,7 @@ impl VirtualMachine {
                 let arg_name = &code_object.arg_names[i];
                 if !scope.contains_key(arg_name) {
                     self.ctx
-                        .set_item(scope, arg_name, available_defaults[default_index].clone());
+                        .set_attr(scope, arg_name, available_defaults[default_index].clone());
                 }
             }
         };