Add object.{__lt__, __le__, __gt__, __gt__}

RustPython · windelbouwman · Feb 12, 2019 · Feb 12, 2019 · Feb 12, 2019 · Feb 12, 2019
commit 0887b55da8e83a8da2398423993a8439b100649d
diff --git a/tests/snippets/object.py b/tests/snippets/object.py
@@ -9,3 +9,7 @@ class MyObject:
 
 assert MyObject().__eq__(MyObject()) == NotImplemented
 assert MyObject().__ne__(MyObject()) == NotImplemented
+assert MyObject().__lt__(MyObject()) == NotImplemented
+assert MyObject().__le__(MyObject()) == NotImplemented
+assert MyObject().__gt__(MyObject()) == NotImplemented
+assert MyObject().__ge__(MyObject()) == NotImplemented
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -990,10 +990,10 @@ impl Frame {
         let value = match *op {
             bytecode::ComparisonOperator::Equal => vm._eq(a, b)?,
             bytecode::ComparisonOperator::NotEqual => vm._ne(a, b)?,
-            bytecode::ComparisonOperator::Less => vm._lt(&a, b)?,
-            bytecode::ComparisonOperator::LessOrEqual => vm._le(&a, b)?,
-            bytecode::ComparisonOperator::Greater => vm._gt(&a, b)?,
-            bytecode::ComparisonOperator::GreaterOrEqual => vm._ge(&a, b)?,
+            bytecode::ComparisonOperator::Less => vm._lt(a, b)?,
+            bytecode::ComparisonOperator::LessOrEqual => vm._le(a, b)?,
+            bytecode::ComparisonOperator::Greater => vm._gt(a, b)?,
+            bytecode::ComparisonOperator::GreaterOrEqual => vm._ge(a, b)?,
             bytecode::ComparisonOperator::Is => vm.ctx.new_bool(self._is(a, b)),
             bytecode::ComparisonOperator::IsNot => self._is_not(vm, a, b)?,
             bytecode::ComparisonOperator::In => self._in(vm, a, b)?,

diff --git a/vm/src/obj/objfloat.rs b/vm/src/obj/objfloat.rs
@@ -100,7 +100,7 @@ fn float_lt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
             .ctx
             .new_bool(v1 < objint::get_value(i2).to_f64().unwrap()))
     } else {
-        Err(vm.new_type_error(format!("Cannot compare {} and {}", i.borrow(), i2.borrow())))
+        Ok(vm.ctx.not_implemented())
     }
 }
 

diff --git a/vm/src/obj/objobject.rs b/vm/src/obj/objobject.rs
@@ -43,6 +43,46 @@ fn object_ne(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.not_implemented())
 }
 
+fn object_lt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(_zelf, Some(vm.ctx.object())), (_other, None)]
+    );
+
+    Ok(vm.ctx.not_implemented())
+}
+
+fn object_le(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(_zelf, Some(vm.ctx.object())), (_other, None)]
+    );
+
+    Ok(vm.ctx.not_implemented())
+}
+
+fn object_gt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(_zelf, Some(vm.ctx.object())), (_other, None)]
+    );
+
+    Ok(vm.ctx.not_implemented())
+}
+
+fn object_ge(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(_zelf, Some(vm.ctx.object())), (_other, None)]
+    );
+
+    Ok(vm.ctx.not_implemented())
+}
+
 fn object_hash(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(_zelf, Some(vm.ctx.object()))]);
 
@@ -91,6 +131,10 @@ pub fn init(context: &PyContext) {
     context.set_attr(&object, "__init__", context.new_rustfunc(object_init));
     context.set_attr(&object, "__eq__", context.new_rustfunc(object_eq));
     context.set_attr(&object, "__ne__", context.new_rustfunc(object_ne));
+    context.set_attr(&object, "__lt__", context.new_rustfunc(object_lt));
+    context.set_attr(&object, "__le__", context.new_rustfunc(object_le));
+    context.set_attr(&object, "__gt__", context.new_rustfunc(object_gt));
+    context.set_attr(&object, "__ge__", context.new_rustfunc(object_ge));
     context.set_attr(&object, "__delattr__", context.new_rustfunc(object_delattr));
     context.set_attr(
         &object,

diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -620,20 +620,28 @@ impl VirtualMachine {
         })
     }
 
-    pub fn _lt(&mut self, a: &PyObjectRef, b: PyObjectRef) -> PyResult {
-        self.call_method(a, "__lt__", vec![b])
+    pub fn _lt(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__lt__", "__lt__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, "<"))
+        })
     }
 
-    pub fn _le(&mut self, a: &PyObjectRef, b: PyObjectRef) -> PyResult {
-        self.call_method(a, "__le__", vec![b])
+    pub fn _le(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__le__", "__le__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, "<="))
+        })
     }
 
-    pub fn _gt(&mut self, a: &PyObjectRef, b: PyObjectRef) -> PyResult {
-        self.call_method(a, "__gt__", vec![b])
+    pub fn _gt(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__gt__", "__gt__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, ">"))
+        })
     }
 
-    pub fn _ge(&mut self, a: &PyObjectRef, b: PyObjectRef) -> PyResult {
-        self.call_method(a, "__ge__", vec![b])
+    pub fn _ge(&mut self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
+        self.call_or_unsupported(a, b, "__ge__", "__ge__", |vm, a, b| {
+            Err(vm.new_unsupported_operand_error(a, b, ">="))
+        })
     }
 }