Merge branch 'master' into fix-unicode-handling

windelbouwman · web-flow · commit b7f6db753fa7 · 2019-02-04T08:39:21.000+01:00
diff --git a/parser/src/lib.rs b/parser/src/lib.rs
@@ -7,6 +7,7 @@ extern crate num_traits;
 pub mod ast;
 pub mod lexer;
 pub mod parser;
+#[cfg_attr(rustfmt, rustfmt_skip)]
 mod python;
 pub mod token;
 
diff --git a/tests/snippets/basic_types.py b/tests/snippets/basic_types.py
@@ -45,6 +45,8 @@
 assert type(a) is complex
 assert type(a + a) is complex
 
+a = 1
+assert a.conjugate() == a
 
 a = 12345
 
diff --git a/tests/snippets/bools.py b/tests/snippets/bools.py
@@ -46,3 +46,5 @@ def __bool__(self):
 assert False * 7 == 0
 assert True > 0
 assert int(True) == 1
+assert True.conjugate() == 1
+assert isinstance(True.conjugate(), int)
diff --git a/tests/snippets/tuple.py b/tests/snippets/tuple.py
@@ -6,6 +6,8 @@
 y = (1,)
 assert y[0] == 1
 
+assert x + y == (1, 2, 1)
+
 assert x * 3 == (1, 2, 1, 2, 1, 2)
 # assert 3 * x == (1, 2, 1, 2, 1, 2)
 assert x * 0 == ()
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -838,21 +838,21 @@ impl Compiler {
                 self.compile_test(expression, None, None, EvalContext::Expression)?
             }
             ast::Expression::Binop { a, op, b } => {
-                self.compile_expression(&*a)?;
-                self.compile_expression(&*b)?;
+                self.compile_expression(a)?;
+                self.compile_expression(b)?;
 
                 // Perform operation:
                 self.compile_op(op);
             }
             ast::Expression::Subscript { a, b } => {
-                self.compile_expression(&*a)?;
-                self.compile_expression(&*b)?;
+                self.compile_expression(a)?;
+                self.compile_expression(b)?;
                 self.emit(Instruction::BinaryOperation {
                     op: bytecode::BinaryOperator::Subscript,
                 });
             }
             ast::Expression::Unop { op, a } => {
-                self.compile_expression(&*a)?;
+                self.compile_expression(a)?;
 
                 // Perform operation:
                 let i = match op {
@@ -865,14 +865,14 @@ impl Compiler {
                 self.emit(i);
             }
             ast::Expression::Attribute { value, name } => {
-                self.compile_expression(&*value)?;
+                self.compile_expression(value)?;
                 self.emit(Instruction::LoadAttr {
                     name: name.to_string(),
                 });
             }
             ast::Expression::Compare { a, op, b } => {
-                self.compile_expression(&*a)?;
-                self.compile_expression(&*b)?;
+                self.compile_expression(a)?;
+                self.compile_expression(b)?;
 
                 let i = match op {
                     ast::Comparison::Equal => bytecode::ComparisonOperator::Equal,
diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
@@ -81,23 +81,23 @@ fn exception_str(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 #[derive(Debug)]
 pub struct ExceptionZoo {
-    pub base_exception_type: PyObjectRef,
-    pub exception_type: PyObjectRef,
-    pub syntax_error: PyObjectRef,
     pub assertion_error: PyObjectRef,
     pub attribute_error: PyObjectRef,
+    pub base_exception_type: PyObjectRef,
+    pub exception_type: PyObjectRef,
+    pub file_not_found_error: PyObjectRef,
+    pub import_error: PyObjectRef,
     pub index_error: PyObjectRef,
     pub key_error: PyObjectRef,
+    pub module_not_found_error: PyObjectRef,
     pub name_error: PyObjectRef,
-    pub runtime_error: PyObjectRef,
     pub not_implemented_error: PyObjectRef,
+    pub permission_error: PyObjectRef,
+    pub runtime_error: PyObjectRef,
     pub stop_iteration: PyObjectRef,
+    pub syntax_error: PyObjectRef,
     pub type_error: PyObjectRef,
     pub value_error: PyObjectRef,
-    pub import_error: PyObjectRef,
-    pub module_not_found_error: PyObjectRef,
-    pub file_not_found_error: PyObjectRef,
-    pub permission_error: PyObjectRef,
 }
 
 impl ExceptionZoo {
@@ -106,11 +106,13 @@ impl ExceptionZoo {
         object_type: &PyObjectRef,
         dict_type: &PyObjectRef,
     ) -> Self {
+        // Sorted By Hierarchy then alphabetized.
+
         let base_exception_type =
             create_type("BaseException", &type_type, &object_type, &dict_type);
 
         let exception_type = create_type("Exception", &type_type, &base_exception_type, &dict_type);
-        let syntax_error = create_type("SyntaxError", &type_type, &exception_type, &dict_type);
+
         let assertion_error =
             create_type("AssertionError", &type_type, &exception_type, &dict_type);
         let attribute_error = create_type(
@@ -119,6 +121,7 @@ impl ExceptionZoo {
             &exception_type.clone(),
             &dict_type,
         );
+        let import_error = create_type("ImportError", &type_type, &exception_type, &dict_type);
         let index_error = create_type(
             "IndexError",
             &type_type,
@@ -128,41 +131,42 @@ impl ExceptionZoo {
         let key_error = create_type("KeyError", &type_type, &exception_type.clone(), &dict_type);
         let name_error = create_type("NameError", &type_type, &exception_type.clone(), &dict_type);
         let runtime_error = create_type("RuntimeError", &type_type, &exception_type, &dict_type);
+        let stop_iteration = create_type("StopIteration", &type_type, &exception_type, &dict_type);
+        let syntax_error = create_type("SyntaxError", &type_type, &exception_type, &dict_type);
+        let type_error = create_type("TypeError", &type_type, &exception_type, &dict_type);
+        let value_error = create_type("ValueError", &type_type, &exception_type, &dict_type);
+
+        let file_not_found_error =
+            create_type("FileNotFoundError", &type_type, &import_error, &dict_type);
+        let module_not_found_error =
+            create_type("ModuleNotFoundError", &type_type, &import_error, &dict_type);
         let not_implemented_error = create_type(
             "NotImplementedError",
             &type_type,
             &runtime_error,
             &dict_type,
         );
-        let stop_iteration = create_type("StopIteration", &type_type, &exception_type, &dict_type);
-        let type_error = create_type("TypeError", &type_type, &exception_type, &dict_type);
-        let value_error = create_type("ValueError", &type_type, &exception_type, &dict_type);
-        let import_error = create_type("ImportError", &type_type, &exception_type, &dict_type);
-        let module_not_found_error =
-            create_type("ModuleNotFoundError", &type_type, &import_error, &dict_type);
-        let file_not_found_error =
-            create_type("FileNotFoundError", &type_type, &import_error, &dict_type);
         let permission_error =
             create_type("PermissionError", &type_type, &import_error, &dict_type);
 
         ExceptionZoo {
-            base_exception_type: base_exception_type,
-            exception_type: exception_type,
-            syntax_error: syntax_error,
             assertion_error: assertion_error,
             attribute_error: attribute_error,
+            base_exception_type: base_exception_type,
+            exception_type: exception_type,
+            file_not_found_error: file_not_found_error,
+            import_error: import_error,
             index_error: index_error,
             key_error: key_error,
+            module_not_found_error: module_not_found_error,
             name_error: name_error,
-            runtime_error: runtime_error,
             not_implemented_error: not_implemented_error,
+            permission_error: permission_error,
+            runtime_error: runtime_error,
             stop_iteration: stop_iteration,
+            syntax_error: syntax_error,
             type_error: type_error,
             value_error: value_error,
-            import_error: import_error,
-            module_not_found_error: module_not_found_error,
-            file_not_found_error: file_not_found_error,
-            permission_error: permission_error,
         }
     }
 }
diff --git a/vm/src/obj/objint.rs b/vm/src/obj/objint.rs
@@ -489,6 +489,12 @@ fn int_bit_length(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_int(bits.to_bigint().unwrap()))
 }
 
+fn int_conjugate(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(i, Some(vm.ctx.int_type()))]);
+    let v = get_value(i);
+    Ok(vm.ctx.new_int(v))
+}
+
 pub fn init(context: &PyContext) {
     let ref int_type = context.int_type;
     context.set_attr(&int_type, "__eq__", context.new_rustfunc(int_eq));
@@ -526,4 +532,5 @@ pub fn init(context: &PyContext) {
         "bit_length",
         context.new_rustfunc(int_bit_length),
     );
+    context.set_attr(&int_type, "conjugate", context.new_rustfunc(int_conjugate));
 }
diff --git a/vm/src/obj/objtuple.rs b/vm/src/obj/objtuple.rs
@@ -10,6 +10,27 @@ use super::objtype;
 use num_bigint::ToBigInt;
 use std::hash::{Hash, Hasher};
 
+fn tuple_add(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(zelf, Some(vm.ctx.tuple_type())), (other, None)]
+    );
+
+    if objtype::isinstance(other, &vm.ctx.tuple_type()) {
+        let e1 = get_elements(zelf);
+        let e2 = get_elements(other);
+        let elements = e1.iter().chain(e2.iter()).map(|e| e.clone()).collect();
+        Ok(vm.ctx.new_tuple(elements))
+    } else {
+        Err(vm.new_type_error(format!(
+            "Cannot add {} and {}",
+            zelf.borrow(),
+            other.borrow()
+        )))
+    }
+}
+
 fn tuple_count(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(
         vm,
@@ -165,6 +186,7 @@ pub fn tuple_contains(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 pub fn init(context: &PyContext) {
     let ref tuple_type = context.tuple_type;
+    context.set_attr(&tuple_type, "__add__", context.new_rustfunc(tuple_add));
     context.set_attr(&tuple_type, "__eq__", context.new_rustfunc(tuple_eq));
     context.set_attr(
         &tuple_type,
