Fixed tuple indexing

Author: Shing Lyu

RustPython/src/main.rs

@@ -509,14 +509,10 @@ impl VirtualMachine {
                 let curr_frame = self.curr_frame();
                 let tos = curr_frame.stack.pop().unwrap();
                 let tos1 = curr_frame.stack.pop().unwrap();
-                if let (NativeType::List(v), NativeType::Int(idx)) = (tos1, tos) {
-                    if idx as usize >= v.len() {
-                        // TODO: change this to a exception
-                        panic!("IndexError: list index out of range");
-                    }
-                    curr_frame.stack.push(v[idx as usize].clone());
-                } else {
-                    panic!("TypeError in BINARY_SUBSTRACT");
+                match (&tos1, &tos) {
+                    (&NativeType::List(ref l), &NativeType::Int(ref index)) => curr_frame.stack.push(l[*index as usize].clone()),
+                    (&NativeType::Tuple(ref t), &NativeType::Int(ref index)) => curr_frame.stack.push(t[*index as usize].clone()),
+                    _ => panic!("TypeError: indexing type {:?} with index {:?} is not supported", tos1, tos)
                 };
                 None
             },
@@ -750,13 +746,17 @@ fn main() {
     let mut s = String::new();
     f.read_to_string(&mut s).unwrap();
     // println!("Read string");
-    let code: PyCodeObject = serde_json::from_str(&s).unwrap();
+    let code: PyCodeObject = match serde_json::from_str(&s) {
+        Ok(c) => c,
+        Err(_) => panic!("Fail to parse the bytecode")
+    };
 
     let mut vm = VirtualMachine::new();
     vm.run_code(code);
     // println!("Done");
 }
 
+/*
 #[test]
 fn test_parse_native_type() {
 
@@ -860,3 +860,10 @@ let input = "{\"co_consts\":[{\"Int\":1},\"NoneType\",{\"Int\":2}],\"co_names\":
     let deserialized: PyCodeObject = serde_json::from_str(&input).unwrap();
     assert_eq!(expected, deserialized)
 }
+*/
+
+#[test]
+fn test_tuple_serialization(){
+    let tuple = NativeType::Tuple(vec![NativeType::Int(1),NativeType::Int(2)]);
+    println!("{}", serde_json::to_string(&tuple).unwrap());
+}

compile_code.py

@@ -28,7 +28,10 @@ def capitalize_first(s):
         return s[0].upper() + s[1:]
 
     def const_to_rust_enum(const):
-        return {capitalize_first(str(type(const).__name__)): const}
+        if type(const).__name__ == "tuple":
+            return {capitalize_first(str(type(const).__name__)): list(map(const_to_rust_enum, const))}
+        else:
+            return {capitalize_first(str(type(const).__name__)): const}
     return list(map(const_to_rust_enum, consts))
 
 

tests/tuple.py

@@ -0,0 +1,2 @@
+x = (1,2)
+assert x[0] == 1