prevent duplicated code generation

Author: youknowone

vm/src/builtins/int.rs

@@ -157,33 +157,50 @@ fn inner_divmod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
     Ok(vm.new_tuple((div, modulo)).into())
 }
 
-fn overflow_shift(int2: &BigInt, vm: &VirtualMachine) -> PyResult<usize> {
-    int2.to_usize().ok_or_else(|| {
-        vm.new_overflow_error("the number is too large to convert to int".to_owned())
-    })
+fn inner_lshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult {
+    inner_shift(
+        base,
+        bits,
+        |base, bits| base << bits,
+        |bits, vm| {
+            bits.to_usize().ok_or_else(|| {
+                vm.new_overflow_error("the number is too large to convert to int".to_owned())
+            })
+        },
+        vm,
+    )
+}
+
+fn inner_rshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult {
+    inner_shift(
+        base,
+        bits,
+        |base, bits| base >> bits,
+        |bits, _vm| Ok(bits.to_usize().unwrap_or(usize::MAX)),
+        vm,
+    )
 }
 
 fn inner_shift<F, S>(
-    int1: &BigInt,
-    int2: &BigInt,
+    base: &BigInt,
+    bits: &BigInt,
     shift_op: F,
-    overflow_shift: S,
+    shift_bits: S,
     vm: &VirtualMachine,
 ) -> PyResult
 where
     F: Fn(&BigInt, usize) -> BigInt,
     S: Fn(&BigInt, &VirtualMachine) -> PyResult<usize>,
 {
-    if int2.is_negative() {
+    if bits.is_negative() {
         Err(vm.new_value_error("negative shift count".to_owned()))
-    } else if int1.is_zero() {
+    } else if base.is_zero() {
         Ok(vm.ctx.new_int(0).into())
     } else {
-        overflow_shift(int2, vm).map(|v| vm.ctx.new_int(shift_op(int1, v)).into())
+        shift_bits(bits, vm).map(|bits| vm.ctx.new_int(shift_op(base, bits)).into())
     }
 }
 
-#[inline]
 fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult {
     if i2.is_zero() {
         return Err(vm.new_zero_division_error("integer division by zero".to_owned()));
@@ -372,54 +389,22 @@ impl PyInt {
 
     #[pymethod(magic)]
     fn lshift(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(
-            other,
-            |a, b| inner_shift(a, b, |a, b| a << b, overflow_shift, vm),
-            vm,
-        )
+        self.general_op(other, |a, b| inner_lshift(a, b, vm), vm)
     }
 
     #[pymethod(magic)]
     fn rlshift(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(
-            other,
-            |a, b| inner_shift(b, a, |a, b| a << b, overflow_shift, vm),
-            vm,
-        )
+        self.general_op(other, |a, b| inner_lshift(b, a, vm), vm)
     }
 
     #[pymethod(magic)]
     fn rshift(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(
-            other,
-            |a, b| {
-                inner_shift(
-                    a,
-                    b,
-                    |a, b| a >> b,
-                    |a, _vm| Ok(a.to_usize().unwrap_or(usize::MAX)),
-                    vm,
-                )
-            },
-            vm,
-        )
+        self.general_op(other, |a, b| inner_rshift(a, b, vm), vm)
     }
 
     #[pymethod(magic)]
     fn rrshift(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(
-            other,
-            |a, b| {
-                inner_shift(
-                    b,
-                    a,
-                    |a, b| a >> b,
-                    |a, _vm| Ok(a.to_usize().unwrap_or(usize::MAX)),
-                    vm,
-                )
-            },
-            vm,
-        )
+        self.general_op(other, |a, b| inner_rshift(b, a, vm), vm)
     }
 
     #[pymethod(name = "__rxor__")]