Merge pull request RustPython#1642 from youknowone/pyreturn

Suggestion: PyReturn to keep result type when it can be a special type like NotImplemented

Author: youknowone

Cargo.lock

@@ -69,6 +69,8 @@ arr_macro = "0.1.2"
 csv = "1.1.1"
 paste = "0.1"
 base64 = "0.11"
+is-macro = "0.1"
+result-like = "^0.2.1"
 
 flame = { version = "0.2", optional = true }
 flamer = { version = "0.3", optional = true }

vm/Cargo.toml

@@ -146,7 +146,7 @@ fn bool_or(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyResult
         let rhs = get_value(&rhs);
         (lhs || rhs).into_pyobject(vm)
     } else {
-        Ok(get_py_int(&lhs).or(rhs.clone(), vm))
+        get_py_int(&lhs).or(rhs.clone(), vm).into_pyobject(vm)
     }
 }
 
@@ -158,7 +158,7 @@ fn bool_and(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyResult
         let rhs = get_value(&rhs);
         (lhs && rhs).into_pyobject(vm)
     } else {
-        Ok(get_py_int(&lhs).and(rhs.clone(), vm))
+        get_py_int(&lhs).and(rhs.clone(), vm).into_pyobject(vm)
     }
 }
 
@@ -170,7 +170,7 @@ fn bool_xor(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyResult
         let rhs = get_value(&rhs);
         (lhs ^ rhs).into_pyobject(vm)
     } else {
-        Ok(get_py_int(&lhs).xor(rhs.clone(), vm))
+        get_py_int(&lhs).xor(rhs.clone(), vm).into_pyobject(vm)
     }
 }
 

vm/src/obj/objbool.rs

@@ -12,8 +12,8 @@ use crate::format::FormatSpec;
 use crate::function::{OptionalArg, OptionalOption};
 use crate::pyhash;
 use crate::pyobject::{
-    IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
-    TypeProtocol,
+    IntoPyObject, PyArithmaticValue::*, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef,
+    PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -196,19 +196,18 @@ impl PyFloat {
         float_op: F,
         int_op: G,
         vm: &VirtualMachine,
-    ) -> PyObjectRef
+    ) -> PyComparisonValue
     where
         F: Fn(f64, f64) -> bool,
         G: Fn(f64, &BigInt) -> bool,
     {
-        let result = if let Some(other) = other.payload_if_subclass::<PyFloat>(vm) {
-            float_op(self.value, other.value)
+        if let Some(other) = other.payload_if_subclass::<PyFloat>(vm) {
+            Implemented(float_op(self.value, other.value))
         } else if let Some(other) = other.payload_if_subclass::<PyInt>(vm) {
-            int_op(self.value, other.as_bigint())
+            Implemented(int_op(self.value, other.as_bigint()))
         } else {
-            return vm.ctx.not_implemented();
-        };
-        vm.ctx.new_bool(result)
+            NotImplemented
+        }
     }
 
     #[pymethod(name = "__format__")]
@@ -222,22 +221,22 @@ impl PyFloat {
     }
 
     #[pymethod(name = "__eq__")]
-    fn eq(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        self.cmp(other, |a, b| a == b, |a, b| int_eq(a, b), vm)
+    fn eq(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyComparisonValue {
+        self.cmp(other, |a, b| a == b, int_eq, vm)
     }
 
     #[pymethod(name = "__ne__")]
-    fn ne(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        self.cmp(other, |a, b| a != b, |a, b| !int_eq(a, b), vm)
+    fn ne(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyComparisonValue {
+        self.eq(other, vm).map(|v| !v)
     }
 
     #[pymethod(name = "__lt__")]
-    fn lt(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        self.cmp(other, |a, b| a < b, |a, b| inner_lt_int(a, b), vm)
+    fn lt(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyComparisonValue {
+        self.cmp(other, |a, b| a < b, inner_lt_int, vm)
     }
 
     #[pymethod(name = "__le__")]
-    fn le(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    fn le(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyComparisonValue {
         self.cmp(
             other,
             |a, b| a <= b,
@@ -253,12 +252,12 @@ impl PyFloat {
     }
 
     #[pymethod(name = "__gt__")]
-    fn gt(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        self.cmp(other, |a, b| a > b, |a, b| inner_gt_int(a, b), vm)
+    fn gt(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyComparisonValue {
+        self.cmp(other, |a, b| a > b, inner_gt_int, vm)
     }
 
     #[pymethod(name = "__ge__")]
-    fn ge(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    fn ge(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyComparisonValue {
         self.cmp(
             other,
             |a, b| a >= b,