Use i-methods for in-place operations

Author: OddCoincidence

vm/src/bytecode.rs

@@ -71,6 +71,7 @@ pub enum Instruction {
     },
     BinaryOperation {
         op: BinaryOperator,
+        inplace: bool,
     },
     LoadAttr {
         name: String,

vm/src/compile.rs

@@ -608,7 +608,7 @@ impl Compiler {
                 self.compile_expression(value)?;
 
                 // Perform operation:
-                self.compile_op(op);
+                self.compile_op(op, true);
                 self.compile_store(target)?;
             }
             ast::Statement::Delete { targets } => {
@@ -757,7 +757,7 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_op(&mut self, op: &ast::Operator) {
+    fn compile_op(&mut self, op: &ast::Operator, inplace: bool) {
         let i = match op {
             ast::Operator::Add => bytecode::BinaryOperator::Add,
             ast::Operator::Sub => bytecode::BinaryOperator::Subtract,
@@ -773,7 +773,7 @@ impl Compiler {
             ast::Operator::BitXor => bytecode::BinaryOperator::Xor,
             ast::Operator::BitAnd => bytecode::BinaryOperator::And,
         };
-        self.emit(Instruction::BinaryOperation { op: i });
+        self.emit(Instruction::BinaryOperation { op: i, inplace });
     }
 
     fn compile_test(
@@ -852,13 +852,14 @@ impl Compiler {
                 self.compile_expression(b)?;
 
                 // Perform operation:
-                self.compile_op(op);
+                self.compile_op(op, false);
             }
             ast::Expression::Subscript { a, b } => {
                 self.compile_expression(a)?;
                 self.compile_expression(b)?;
                 self.emit(Instruction::BinaryOperation {
                     op: bytecode::BinaryOperator::Subscript,
+                    inplace: false,
                 });
             }
             ast::Expression::Unop { op, a } => {

vm/src/frame.rs

@@ -316,7 +316,9 @@ impl Frame {
                 vm.call_method(&dict_obj, "__setitem__", vec![key, value])?;
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOperation { ref op } => self.execute_binop(vm, op),
+            bytecode::Instruction::BinaryOperation { ref op, inplace } => {
+                self.execute_binop(vm, op, *inplace)
+            }
             bytecode::Instruction::LoadAttr { ref name } => self.load_attr(vm, name),
             bytecode::Instruction::StoreAttr { ref name } => self.store_attr(vm, name),
             bytecode::Instruction::DeleteAttr { ref name } => self.delete_attr(vm, name),
@@ -893,23 +895,39 @@ impl Frame {
         &mut self,
         vm: &mut VirtualMachine,
         op: &bytecode::BinaryOperator,
+        inplace: bool,
     ) -> FrameResult {
         let b_ref = self.pop_value();
         let a_ref = self.pop_value();
         let value = match *op {
+            bytecode::BinaryOperator::Subtract if inplace => vm._isub(a_ref, b_ref),
             bytecode::BinaryOperator::Subtract => vm._sub(a_ref, b_ref),
+            bytecode::BinaryOperator::Add if inplace => vm._iadd(a_ref, b_ref),
             bytecode::BinaryOperator::Add => vm._add(a_ref, b_ref),
+            bytecode::BinaryOperator::Multiply if inplace => vm._imul(a_ref, b_ref),
             bytecode::BinaryOperator::Multiply => vm._mul(a_ref, b_ref),
+            bytecode::BinaryOperator::MatrixMultiply if inplace => vm._imatmul(a_ref, b_ref),
             bytecode::BinaryOperator::MatrixMultiply => vm._matmul(a_ref, b_ref),
+            bytecode::BinaryOperator::Power if inplace => vm._ipow(a_ref, b_ref),
             bytecode::BinaryOperator::Power => vm._pow(a_ref, b_ref),
+            bytecode::BinaryOperator::Divide if inplace => vm._itruediv(a_ref, b_ref),
             bytecode::BinaryOperator::Divide => vm._truediv(a_ref, b_ref),
+            bytecode::BinaryOperator::FloorDivide if inplace => vm._ifloordiv(a_ref, b_ref),
             bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
+            // TODO: Subscript should probably have its own op
+            bytecode::BinaryOperator::Subscript if inplace => unreachable!(),
             bytecode::BinaryOperator::Subscript => self.subscript(vm, a_ref, b_ref),
+            bytecode::BinaryOperator::Modulo if inplace => vm._imod(a_ref, b_ref),
             bytecode::BinaryOperator::Modulo => vm._mod(a_ref, b_ref),
+            bytecode::BinaryOperator::Lshift if inplace => vm._ilshift(a_ref, b_ref),
             bytecode::BinaryOperator::Lshift => vm._lshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Rshift if inplace => vm._irshift(a_ref, b_ref),
             bytecode::BinaryOperator::Rshift => vm._rshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Xor if inplace => vm._ixor(a_ref, b_ref),
             bytecode::BinaryOperator::Xor => vm._xor(a_ref, b_ref),
+            bytecode::BinaryOperator::Or if inplace => vm._ior(a_ref, b_ref),
             bytecode::BinaryOperator::Or => vm._or(a_ref, b_ref),
+            bytecode::BinaryOperator::And if inplace => vm._iand(a_ref, b_ref),
             bytecode::BinaryOperator::And => vm._and(a_ref, b_ref),
         }?;