Add some tuple class methods

Author: windelbouwman

vm/src/obj/mod.rs

@@ -7,4 +7,5 @@ pub mod objlist;
 pub mod objobject;
 pub mod objsequence;
 pub mod objstr;
+pub mod objtuple;
 pub mod objtype;

vm/src/obj/objbytes.rs

@@ -1,6 +1,5 @@
 use super::super::pyobject::{
-    AttributeProtocol, FromPyObjectRef, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult,
-    TypeProtocol,
+    AttributeProtocol, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 use super::objint;
@@ -24,7 +23,7 @@ fn bytes_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     );
     let val = if objtype::isinstance(arg.clone(), vm.ctx.list_type()) {
         let mut data_bytes = vec![];
-        for elem in objlist::get_elements(arg.clone()) {
+        for elem in objlist::get_elements(arg) {
             let v = match objint::to_int(vm, &elem) {
                 Ok(int_ref) => int_ref,
                 Err(err) => return Err(err),

vm/src/obj/objlist.rs

@@ -26,7 +26,7 @@ pub fn set_item(
     }
 }
 
-pub fn get_elements(obj: PyObjectRef) -> Vec<PyObjectRef> {
+pub fn get_elements(obj: &PyObjectRef) -> Vec<PyObjectRef> {
     if let PyObjectKind::List { elements } = &obj.borrow().kind {
         elements.to_vec()
     } else {
@@ -42,8 +42,8 @@ fn list_add(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     );
 
     if objtype::isinstance(o2.clone(), vm.ctx.list_type()) {
-        let e1 = get_elements(o.clone());
-        let e2 = get_elements(o2.clone());
+        let e1 = get_elements(o);
+        let e2 = get_elements(o2);
         let elements = e1.iter().chain(e2.iter()).map(|e| e.clone()).collect();
         Ok(vm.ctx.new_list(elements))
     } else {
@@ -54,7 +54,7 @@ fn list_add(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn list_str(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(o, Some(vm.ctx.list_type()))]);
 
-    let elements = get_elements(o.clone());
+    let elements = get_elements(o);
     let mut str_parts = vec![];
     for elem in elements {
         match vm.to_str(elem) {
@@ -95,15 +95,10 @@ fn clear(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     }
 }
 
-fn len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    trace!("list.len called with: {:?}", args);
+fn list_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(list, Some(vm.ctx.list_type()))]);
-    let list_obj = list.borrow();
-    if let PyObjectKind::List { ref elements } = list_obj.kind {
-        Ok(vm.context().new_int(elements.len() as i32))
-    } else {
-        Err(vm.new_type_error("list.len is called with no list".to_string()))
-    }
+    let elements = get_elements(list);
+    Ok(vm.context().new_int(elements.len() as i32))
 }
 
 fn reverse(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -121,7 +116,7 @@ fn reverse(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 pub fn init(context: &PyContext) {
     let ref list_type = context.list_type;
     list_type.set_attr("__add__", context.new_rustfunc(list_add));
-    list_type.set_attr("__len__", context.new_rustfunc(len));
+    list_type.set_attr("__len__", context.new_rustfunc(list_len));
     list_type.set_attr("__str__", context.new_rustfunc(list_str));
     list_type.set_attr("append", context.new_rustfunc(append));
     list_type.set_attr("clear", context.new_rustfunc(clear));

vm/src/obj/objtuple.rs

@@ -0,0 +1,46 @@
+use super::super::pyobject::{
+    AttributeProtocol, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+};
+use super::super::vm::VirtualMachine;
+use super::objstr;
+use super::objtype;
+
+fn tuple_str(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(o, Some(vm.ctx.tuple_type()))]);
+
+    let elements = get_elements(o);
+    let mut str_parts = vec![];
+    for elem in elements {
+        match vm.to_str(elem) {
+            Ok(s) => str_parts.push(objstr::get_value(&s)),
+            Err(err) => return Err(err),
+        }
+    }
+
+    let s = if str_parts.len() == 1 {
+        format!("({},)", str_parts.join(", "))
+    } else {
+        format!("({})", str_parts.join(", "))
+    };
+    Ok(vm.new_str(s))
+}
+
+pub fn get_elements(obj: &PyObjectRef) -> Vec<PyObjectRef> {
+    if let PyObjectKind::List { elements } = &obj.borrow().kind {
+        elements.to_vec()
+    } else {
+        panic!("Cannot extract elements from non-tuple");
+    }
+}
+
+fn tuple_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(tuple, Some(vm.ctx.tuple_type()))]);
+    let elements = get_elements(tuple);
+    Ok(vm.context().new_int(elements.len() as i32))
+}
+
+pub fn init(context: &PyContext) {
+    let ref tuple_type = context.tuple_type;
+    tuple_type.set_attr("__len__", context.new_rustfunc(tuple_len));
+    tuple_type.set_attr("__str__", context.new_rustfunc(tuple_str));
+}

vm/src/pyobject.rs

@@ -8,6 +8,7 @@ use super::obj::objint;
 use super::obj::objlist;
 use super::obj::objobject;
 use super::obj::objstr;
+use super::obj::objtuple;
 use super::obj::objtype;
 use super::objbool;
 use super::vm::VirtualMachine;
@@ -152,10 +153,9 @@ impl PyContext {
         objfloat::init(&context);
         objbytes::init(&context);
         objstr::init(&context);
+        objtuple::init(&context);
         objbool::init(&context);
         exceptions::init(&context);
-        // TODO: create exception hierarchy here?
-        // exceptions::create_zoo(&context);
         context
     }
 

vm/src/stdlib/json.rs

@@ -52,7 +52,7 @@ impl<'s> serde::Serialize for PyObjectSerializer<'s> {
         } else if objtype::isinstance(self.pyobject.clone(), self.vm.ctx.bool_type()) {
             serializer.serialize_bool(objbool::get_value(self.pyobject))
         } else if objtype::isinstance(self.pyobject.clone(), self.vm.ctx.list_type()) {
-            let elements = objlist::get_elements(self.pyobject.clone());
+            let elements = objlist::get_elements(self.pyobject);
             serialize_seq_elements(serializer, elements)
         } else if objtype::isinstance(self.pyobject.clone(), self.vm.ctx.tuple_type()) {
             let elements = objsequence::get_elements(self.pyobject.clone());