Implement remaining binop reverse fallbacks

OddCoincidence · OddCoincidence · commit fe3f45f6557e · 2019-02-17T09:26:31.000-08:00
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -900,18 +900,14 @@ impl Frame {
             bytecode::BinaryOperator::Subtract => vm._sub(a_ref, b_ref),
             bytecode::BinaryOperator::Add => vm._add(a_ref, b_ref),
             bytecode::BinaryOperator::Multiply => vm._mul(a_ref, b_ref),
-            bytecode::BinaryOperator::MatrixMultiply => {
-                vm.call_method(&a_ref, "__matmul__", vec![b_ref])
-            }
+            bytecode::BinaryOperator::MatrixMultiply => vm._matmul(a_ref, b_ref),
             bytecode::BinaryOperator::Power => vm._pow(a_ref, b_ref),
-            bytecode::BinaryOperator::Divide => vm._div(a_ref, b_ref),
-            bytecode::BinaryOperator::FloorDivide => {
-                vm.call_method(&a_ref, "__floordiv__", vec![b_ref])
-            }
+            bytecode::BinaryOperator::Divide => vm._truediv(a_ref, b_ref),
+            bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
             bytecode::BinaryOperator::Subscript => self.subscript(vm, a_ref, b_ref),
-            bytecode::BinaryOperator::Modulo => vm._modulo(a_ref, b_ref),
-            bytecode::BinaryOperator::Lshift => vm.call_method(&a_ref, "__lshift__", vec![b_ref]),
-            bytecode::BinaryOperator::Rshift => vm.call_method(&a_ref, "__rshift__", vec![b_ref]),
+            bytecode::BinaryOperator::Modulo => vm._mod(a_ref, b_ref),
+            bytecode::BinaryOperator::Lshift => vm._lshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Rshift => vm._rshift(a_ref, b_ref),
             bytecode::BinaryOperator::Xor => vm._xor(a_ref, b_ref),
             bytecode::BinaryOperator::Or => vm._or(a_ref, b_ref),
             bytecode::BinaryOperator::And => vm._and(a_ref, b_ref),
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -571,24 +571,48 @@ impl VirtualMachine {
         })
     }
 
-    pub fn _div(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+    pub fn _matmul(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__matmul__", "__rmatmul__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, "@"))
+        })
+    }
+
+    pub fn _truediv(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
         self.call_or_unsupported(a, b, "__truediv__", "__rtruediv__", |vm, a, b| {
             Err(vm.new_unsupported_operand_error(a, b, "/"))
         })
     }
 
+    pub fn _floordiv(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__floordiv__", "__rfloordiv__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, "//"))
+        })
+    }
+
     pub fn _pow(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
         self.call_or_unsupported(a, b, "__pow__", "__rpow__", |vm, a, b| {
             Err(vm.new_unsupported_operand_error(a, b, "**"))
         })
     }
 
-    pub fn _modulo(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+    pub fn _mod(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
         self.call_or_unsupported(a, b, "__mod__", "__rmod__", |vm, a, b| {
             Err(vm.new_unsupported_operand_error(a, b, "%"))
         })
     }
 
+    pub fn _lshift(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__lshift__", "__rlshift__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, "<<"))
+        })
+    }
+
+    pub fn _rshift(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__rshift__", "__rrshift__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, ">>"))
+        })
+    }
+
     pub fn _xor(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
         self.call_or_unsupported(a, b, "__xor__", "__rxor__", |vm, a, b| {
             Err(vm.new_unsupported_operand_error(a, b, "^"))
