Modify location of set_attr so that we are able to create str python objects for the dictionary.

Author: windelbouwman

vm/src/builtins.rs

@@ -679,7 +679,7 @@ fn builtin_setattr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(obj, None), (attr, Some(vm.ctx.str_type())), (value, None)]
     );
     let name = objstr::get_value(attr);
-    obj.clone().set_attr(&name, value.clone());
+    vm.ctx.set_attr(obj, &name, value.clone());
     Ok(vm.get_none())
 }
 

vm/src/exceptions.rs

@@ -14,8 +14,8 @@ fn exception_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         vm.new_str("No msg".to_string())
     };
     let traceback = vm.ctx.new_list(Vec::new());
-    zelf.set_attr("msg", msg);
-    zelf.set_attr("__traceback__", traceback);
+    vm.ctx.set_attr(&zelf, "msg", msg);
+    vm.ctx.set_attr(&zelf, "__traceback__", traceback);
     Ok(vm.get_none())
 }
 
@@ -198,7 +198,15 @@ impl ExceptionZoo {
 
 pub fn init(context: &PyContext) {
     let ref base_exception_type = context.exceptions.base_exception_type;
-    base_exception_type.set_attr("__init__", context.new_rustfunc(exception_init));
+    context.set_attr(
+        &base_exception_type,
+        "__init__",
+        context.new_rustfunc(exception_init),
+    );
     let ref exception_type = context.exceptions.exception_type;
-    exception_type.set_attr("__str__", context.new_rustfunc(exception_str));
+    context.set_attr(
+        &exception_type,
+        "__str__",
+        context.new_rustfunc(exception_str),
+    );
 }

vm/src/frame.rs

@@ -16,8 +16,8 @@ use super::obj::objlist;
 use super::obj::objstr;
 use super::obj::objtype;
 use super::pyobject::{
-    AttributeProtocol, DictProtocol, IdProtocol, ParentProtocol, PyFuncArgs, PyObject,
-    PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+    DictProtocol, IdProtocol, ParentProtocol, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef,
+    PyResult, TypeProtocol,
 };
 use super::vm::VirtualMachine;
 use num_bigint::ToBigInt;
@@ -309,7 +309,7 @@ impl Frame {
             }
             bytecode::Instruction::BinaryOperation { ref op } => self.execute_binop(vm, op),
             bytecode::Instruction::LoadAttr { ref name } => self.load_attr(vm, name),
-            bytecode::Instruction::StoreAttr { ref name } => self.store_attr(name),
+            bytecode::Instruction::StoreAttr { ref name } => self.store_attr(vm, name),
             bytecode::Instruction::DeleteAttr { ref name } => self.delete_attr(vm, name),
             bytecode::Instruction::UnaryOperation { ref op } => self.execute_unop(vm, op),
             bytecode::Instruction::CompareOperation { ref op } => self.execute_compare(vm, op),
@@ -998,10 +998,10 @@ impl Frame {
         Ok(None)
     }
 
-    fn store_attr(&mut self, attr_name: &str) -> FrameResult {
+    fn store_attr(&mut self, vm: &mut VirtualMachine, attr_name: &str) -> FrameResult {
         let parent = self.pop_value();
         let value = self.pop_value();
-        parent.set_attr(attr_name, value);
+        vm.ctx.set_attr(&parent, attr_name, value);
         Ok(None)
     }
 

vm/src/obj/objbool.rs

@@ -1,5 +1,5 @@
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+    PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objtype;
@@ -31,8 +31,8 @@ pub fn boolval(vm: &mut VirtualMachine, obj: PyObjectRef) -> Result<bool, PyObje
 
 pub fn init(context: &PyContext) {
     let ref bool_type = context.bool_type;
-    bool_type.set_attr("__new__", context.new_rustfunc(bool_new));
-    bool_type.set_attr("__repr__", context.new_rustfunc(bool_repr));
+    context.set_attr(&bool_type, "__new__", context.new_rustfunc(bool_new));
+    context.set_attr(&bool_type, "__repr__", context.new_rustfunc(bool_repr));
 }
 
 pub fn not(vm: &mut VirtualMachine, obj: &PyObjectRef) -> PyResult {

vm/src/obj/objbytearray.rs

@@ -1,8 +1,7 @@
 //! Implementation of the python bytearray object.
 
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objbytes::get_value;
@@ -14,9 +13,21 @@ use num_traits::ToPrimitive;
 /// Fill bytearray class methods dictionary.
 pub fn init(context: &PyContext) {
     let ref bytearray_type = context.bytearray_type;
-    bytearray_type.set_attr("__eq__", context.new_rustfunc(bytearray_eq));
-    bytearray_type.set_attr("__new__", context.new_rustfunc(bytearray_new));
-    bytearray_type.set_attr("__repr__", context.new_rustfunc(bytearray_repr));
+    context.set_attr(
+        &bytearray_type,
+        "__eq__",
+        context.new_rustfunc(bytearray_eq),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "__new__",
+        context.new_rustfunc(bytearray_new),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "__repr__",
+        context.new_rustfunc(bytearray_repr),
+    );
 }
 
 fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objbytes.rs

@@ -1,6 +1,5 @@
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objint;
@@ -15,10 +14,10 @@ use std::ops::Deref;
 // Fill bytes class methods:
 pub fn init(context: &PyContext) {
     let ref bytes_type = context.bytes_type;
-    bytes_type.set_attr("__eq__", context.new_rustfunc(bytes_eq));
-    bytes_type.set_attr("__hash__", context.new_rustfunc(bytes_hash));
-    bytes_type.set_attr("__new__", context.new_rustfunc(bytes_new));
-    bytes_type.set_attr("__repr__", context.new_rustfunc(bytes_repr));
+    context.set_attr(bytes_type, "__eq__", context.new_rustfunc(bytes_eq));
+    context.set_attr(bytes_type, "__hash__", context.new_rustfunc(bytes_hash));
+    context.set_attr(bytes_type, "__new__", context.new_rustfunc(bytes_new));
+    context.set_attr(bytes_type, "__repr__", context.new_rustfunc(bytes_repr));
 }
 
 fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objcode.rs

@@ -4,15 +4,15 @@
 
 use super::super::bytecode;
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+    PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objtype;
 
 pub fn init(context: &PyContext) {
     let ref code_type = context.code_type;
-    code_type.set_attr("__new__", context.new_rustfunc(code_new));
-    code_type.set_attr("__repr__", context.new_rustfunc(code_repr));
+    context.set_attr(code_type, "__new__", context.new_rustfunc(code_new));
+    context.set_attr(code_type, "__repr__", context.new_rustfunc(code_repr));
 }
 
 /// Extract rust bytecode object from a python code object.

vm/src/obj/objcomplex.rs

@@ -1,6 +1,5 @@
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objfloat;
@@ -9,10 +8,18 @@ use num_complex::Complex64;
 
 pub fn init(context: &PyContext) {
     let ref complex_type = context.complex_type;
-    complex_type.set_attr("__add__", context.new_rustfunc(complex_add));
-    complex_type.set_attr("__new__", context.new_rustfunc(complex_new));
-    complex_type.set_attr("__repr__", context.new_rustfunc(complex_repr));
-    complex_type.set_attr("conjugate", context.new_rustfunc(complex_conjugate));
+    context.set_attr(&complex_type, "__add__", context.new_rustfunc(complex_add));
+    context.set_attr(&complex_type, "__new__", context.new_rustfunc(complex_new));
+    context.set_attr(
+        &complex_type,
+        "__repr__",
+        context.new_rustfunc(complex_repr),
+    );
+    context.set_attr(
+        &complex_type,
+        "conjugate",
+        context.new_rustfunc(complex_conjugate),
+    );
 }
 
 pub fn get_value(obj: &PyObjectRef) -> Complex64 {

vm/src/obj/objdict.rs

@@ -1,6 +1,5 @@
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objstr;
@@ -212,12 +211,28 @@ pub fn create_type(type_type: PyObjectRef, object_type: PyObjectRef, dict_type:
 
 pub fn init(context: &PyContext) {
     let ref dict_type = context.dict_type;
-    dict_type.set_attr("__len__", context.new_rustfunc(dict_len));
-    dict_type.set_attr("__contains__", context.new_rustfunc(dict_contains));
-    dict_type.set_attr("__delitem__", context.new_rustfunc(dict_delitem));
-    dict_type.set_attr("__getitem__", context.new_rustfunc(dict_getitem));
-    dict_type.set_attr("__iter__", context.new_rustfunc(dict_iter));
-    dict_type.set_attr("__new__", context.new_rustfunc(dict_new));
-    dict_type.set_attr("__repr__", context.new_rustfunc(dict_repr));
-    dict_type.set_attr("__setitem__", context.new_rustfunc(dict_setitem));
+    context.set_attr(&dict_type, "__len__", context.new_rustfunc(dict_len));
+    context.set_attr(
+        &dict_type,
+        "__contains__",
+        context.new_rustfunc(dict_contains),
+    );
+    context.set_attr(
+        &dict_type,
+        "__delitem__",
+        context.new_rustfunc(dict_delitem),
+    );
+    context.set_attr(
+        &dict_type,
+        "__getitem__",
+        context.new_rustfunc(dict_getitem),
+    );
+    context.set_attr(&dict_type, "__iter__", context.new_rustfunc(dict_iter));
+    context.set_attr(&dict_type, "__new__", context.new_rustfunc(dict_new));
+    context.set_attr(&dict_type, "__repr__", context.new_rustfunc(dict_repr));
+    context.set_attr(
+        &dict_type,
+        "__setitem__",
+        context.new_rustfunc(dict_setitem),
+    );
 }

vm/src/obj/objfloat.rs

@@ -1,5 +1,5 @@
 use super::super::pyobject::{
-    AttributeProtocol, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+    PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objint;
@@ -260,19 +260,27 @@ fn float_pow(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 pub fn init(context: &PyContext) {
     let ref float_type = context.float_type;
-    float_type.set_attr("__eq__", context.new_rustfunc(float_eq));
-    float_type.set_attr("__lt__", context.new_rustfunc(float_lt));
-    float_type.set_attr("__le__", context.new_rustfunc(float_le));
-    float_type.set_attr("__gt__", context.new_rustfunc(float_gt));
-    float_type.set_attr("__ge__", context.new_rustfunc(float_ge));
-    float_type.set_attr("__abs__", context.new_rustfunc(float_abs));
-    float_type.set_attr("__add__", context.new_rustfunc(float_add));
-    float_type.set_attr("__divmod__", context.new_rustfunc(float_divmod));
-    float_type.set_attr("__floordiv__", context.new_rustfunc(float_floordiv));
-    float_type.set_attr("__init__", context.new_rustfunc(float_init));
-    float_type.set_attr("__mod__", context.new_rustfunc(float_mod));
-    float_type.set_attr("__neg__", context.new_rustfunc(float_neg));
-    float_type.set_attr("__pow__", context.new_rustfunc(float_pow));
-    float_type.set_attr("__sub__", context.new_rustfunc(float_sub));
-    float_type.set_attr("__repr__", context.new_rustfunc(float_repr));
+    context.set_attr(&float_type, "__eq__", context.new_rustfunc(float_eq));
+    context.set_attr(&float_type, "__lt__", context.new_rustfunc(float_lt));
+    context.set_attr(&float_type, "__le__", context.new_rustfunc(float_le));
+    context.set_attr(&float_type, "__gt__", context.new_rustfunc(float_gt));
+    context.set_attr(&float_type, "__ge__", context.new_rustfunc(float_ge));
+    context.set_attr(&float_type, "__abs__", context.new_rustfunc(float_abs));
+    context.set_attr(&float_type, "__add__", context.new_rustfunc(float_add));
+    context.set_attr(
+        &float_type,
+        "__divmod__",
+        context.new_rustfunc(float_divmod),
+    );
+    context.set_attr(
+        &float_type,
+        "__floordiv__",
+        context.new_rustfunc(float_floordiv),
+    );
+    context.set_attr(&float_type, "__init__", context.new_rustfunc(float_init));
+    context.set_attr(&float_type, "__mod__", context.new_rustfunc(float_mod));
+    context.set_attr(&float_type, "__neg__", context.new_rustfunc(float_neg));
+    context.set_attr(&float_type, "__pow__", context.new_rustfunc(float_pow));
+    context.set_attr(&float_type, "__sub__", context.new_rustfunc(float_sub));
+    context.set_attr(&float_type, "__repr__", context.new_rustfunc(float_repr));
 }