Implement some __ne__ methods (#1446)

makarchuk · youknowone · commit 4b962b89d70a · 2019-10-06T00:50:02.000+09:00
* Implement some __ne__ methods

Added test snippets from `__ne__` methods

* Fix incompatability in str.__eq__ befaviour

Previously "".__eq__(1) returned "False", which is not the case in
cpython.
Not it's returning 'NotImplemented', as it should
diff --git a/tests/snippets/dict.py b/tests/snippets/dict.py
@@ -251,3 +251,6 @@ def __eq__(self, other):
 assert isinstance(c, set)
 assert c == {'bla', 'c', 'd', 'f'}
 
+assert not {}.__ne__({})
+assert {}.__ne__({'a':'b'})
+assert {}.__ne__(1) == NotImplemented
diff --git a/tests/snippets/list.py b/tests/snippets/list.py
@@ -489,6 +489,11 @@ def bad_iter_assign():
 x = list(range(10))
 del x[-5:-1:-1]
 
+assert [1, 2].__ne__([])
+assert [2, 1].__ne__([1, 2])
+assert not [1, 2].__ne__([1, 2])
+assert [1, 2].__ne__(1) == NotImplemented
+
 # list gt, ge, lt, le
 assert_raises(TypeError, lambda: [0, []] < [0, 0])
 assert_raises(TypeError, lambda: [0, []] <= [0, 0])
diff --git a/tests/snippets/set.py b/tests/snippets/set.py
@@ -327,3 +327,13 @@ def __hash__(self):
 assert x == (EqObject(x) == EqObject(x))
 s = {EqObject(x)}
 assert EqObject(x) in s
+
+assert set([1, 2]).__ne__(set())
+assert not set([1, 2]).__ne__(set([2, 1]))
+assert set().__ne__(1) == NotImplemented
+
+assert frozenset([1, 2]).__ne__(set())
+assert frozenset([1, 2]).__ne__(frozenset())
+assert not frozenset([1, 2]).__ne__(set([2, 1]))
+assert not frozenset([1, 2]).__ne__(frozenset([2, 1]))
+assert frozenset().__ne__(1) == NotImplemented
diff --git a/tests/snippets/strings.py b/tests/snippets/strings.py
@@ -1,5 +1,6 @@
 from testutils import assert_raises
 
+assert "".__eq__(1) == NotImplemented
 assert "a" == 'a'
 assert """a""" == "a"
 assert len(""" " "" " "" """) == 11
@@ -311,3 +312,9 @@ def try_mutate_str():
 assert index_str[-1] == 'n'
 
 assert_raises(TypeError, lambda: index_str['a'])
+
+
+assert "a".__ne__("b")
+assert not "a".__ne__("a")
+assert not "".__ne__("")
+assert "".__ne__(1) == NotImplemented
diff --git a/tests/snippets/tuple.py b/tests/snippets/tuple.py
@@ -50,6 +50,9 @@ def __eq__(self, x):
 b = ()
 assert a is b
 
+assert (1,).__ne__((2,))
+assert not (1,).__ne__((1,))
+
 # tuple gt, ge, lt, le
 assert_raises(TypeError, lambda: (0, ()) < (0, 0))
 assert_raises(TypeError, lambda: (0, ()) <= (0, 0))
@@ -87,4 +90,4 @@ def __eq__(self, x):
 assert (float('inf'), float('inf')) <= (float('inf'), float('inf'))
 assert (float('inf'), float('inf')) >= (float('inf'), float('inf'))
 assert not (float('inf'), float('inf')) < (float('inf'), float('inf'))
-assert not (float('inf'), float('inf')) > (float('inf'), float('inf'))
+assert not (float('inf'), float('inf')) > (float('inf'), float('inf'))
diff --git a/vm/src/obj/objdict.rs b/vm/src/obj/objdict.rs
@@ -146,6 +146,15 @@ impl PyDictRef {
         }
     }
 
+    fn ne(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if let Some(other) = other.payload::<PyDict>() {
+            let neq = !self.inner_eq(other, vm)?;
+            Ok(vm.ctx.new_bool(neq))
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+
     fn len(self, _vm: &VirtualMachine) -> usize {
         self.entries.borrow().len()
     }
@@ -575,6 +584,7 @@ pub fn init(context: &PyContext) {
         "__contains__" => context.new_rustfunc(PyDictRef::contains),
         "__delitem__" => context.new_rustfunc(PyDictRef::inner_delitem),
         "__eq__" => context.new_rustfunc(PyDictRef::eq),
+        "__ne__" => context.new_rustfunc(PyDictRef::ne),
         "__getitem__" => context.new_rustfunc(PyDictRef::inner_getitem),
         "__iter__" => context.new_rustfunc(PyDictRef::iter),
         (slot new) => PyDictRef::new,
diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -508,17 +508,30 @@ impl PyListRef {
         if self.as_object().is(&other) {
             return Ok(vm.new_bool(true));
         }
+        if objtype::isinstance(&other, &vm.ctx.list_type()) {
+            Ok(vm.new_bool(self.inner_eq(&other, vm)?))
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
 
+    fn ne(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if self.as_object().is(&other) {
+            return Ok(vm.new_bool(false));
+        }
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
-            let zelf = self.elements.borrow();
-            let other = get_elements_list(&other);
-            let res = seq_equal(vm, &zelf.as_slice(), &other.as_slice())?;
-            Ok(vm.new_bool(res))
+            Ok(vm.new_bool(!self.inner_eq(&other, vm)?))
         } else {
             Ok(vm.ctx.not_implemented())
         }
     }
 
+    fn inner_eq(self, other: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        let zelf = self.elements.borrow();
+        let other = get_elements_list(other);
+        seq_equal(vm, &zelf.as_slice(), &other.as_slice())
+    }
+
     fn lt(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
             let zelf = self.elements.borrow();
@@ -869,6 +882,7 @@ pub fn init(context: &PyContext) {
         "__contains__" => context.new_rustfunc(PyListRef::contains),
         "__delitem__" => context.new_rustfunc(PyListRef::delitem),
         "__eq__" => context.new_rustfunc(PyListRef::eq),
+        "__ne__" => context.new_rustfunc(PyListRef::ne),
         "__lt__" => context.new_rustfunc(PyListRef::lt),
         "__gt__" => context.new_rustfunc(PyListRef::gt),
         "__le__" => context.new_rustfunc(PyListRef::le),
diff --git a/vm/src/obj/objset.rs b/vm/src/obj/objset.rs
@@ -2,6 +2,7 @@
  * Builtin set type with a sequence of unique items.
  */
 
+use std::borrow::Borrow;
 use std::cell::{Cell, RefCell};
 use std::fmt;
 
@@ -13,6 +14,7 @@ use crate::pyobject::{
 };
 use crate::vm::{ReprGuard, VirtualMachine};
 
+use super::objbool;
 use super::objlist::PyListIterator;
 use super::objtype;
 use super::objtype::PyClassRef;
@@ -133,6 +135,11 @@ impl PySetInner {
         )
     }
 
+    fn ne(&self, other: &PySetInner, vm: &VirtualMachine) -> PyResult {
+        let eq = objbool::get_value(self.eq(other, vm)?.borrow());
+        Ok(vm.new_bool(!eq))
+    }
+
     fn ge(&self, other: &PySetInner, vm: &VirtualMachine) -> PyResult {
         self._compare_inner(
             other,
@@ -358,6 +365,11 @@ impl PySet {
         try_set_inner!(vm, other, |other| self.inner.borrow().eq(other, vm))
     }
 
+    #[pymethod(name = "__ne__")]
+    fn ne(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_set_inner!(vm, other, |other| self.inner.borrow().ne(other, vm))
+    }
+
     #[pymethod(name = "__ge__")]
     fn ge(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         try_set_inner!(vm, other, |other| self.inner.borrow().ge(other, vm))
@@ -604,6 +616,11 @@ impl PyFrozenSet {
         try_set_inner!(vm, other, |other| self.inner.eq(other, vm))
     }
 
+    #[pymethod(name = "__ne__")]
+    fn ne(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_set_inner!(vm, other, |other| self.inner.ne(other, vm))
+    }
+
     #[pymethod(name = "__ge__")]
     fn ge(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         try_set_inner!(vm, other, |other| self.inner.ge(other, vm))
diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -207,11 +207,20 @@ impl PyString {
     }
 
     #[pymethod(name = "__eq__")]
-    fn eq(&self, rhs: PyObjectRef, vm: &VirtualMachine) -> bool {
+    fn eq(&self, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         if objtype::isinstance(&rhs, &vm.ctx.str_type()) {
-            self.value == get_value(&rhs)
+            vm.new_bool(self.value == get_value(&rhs))
         } else {
-            false
+            vm.ctx.not_implemented()
+        }
+    }
+
+    #[pymethod(name = "__ne__")]
+    fn ne(&self, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        if objtype::isinstance(&rhs, &vm.ctx.str_type()) {
+            vm.new_bool(self.value != get_value(&rhs))
+        } else {
+            vm.ctx.not_implemented()
         }
     }
 
diff --git a/vm/src/obj/objtuple.rs b/vm/src/obj/objtuple.rs
@@ -144,14 +144,25 @@ impl PyTupleRef {
 
     fn eq(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
-            let other = get_elements_tuple(&other);
-            let res = seq_equal(vm, &self.elements.as_slice(), &other.as_slice())?;
-            Ok(vm.new_bool(res))
+            Ok(vm.new_bool(self.inner_eq(&other, vm)?))
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+
+    fn ne(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
+            Ok(vm.new_bool(!self.inner_eq(&other, vm)?))
         } else {
             Ok(vm.ctx.not_implemented())
         }
     }
 
+    fn inner_eq(&self, other: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        let other = get_elements_tuple(other);
+        seq_equal(vm, &self.elements.as_slice(), &other.as_slice())
+    }
+
     fn hash(self, vm: &VirtualMachine) -> PyResult<pyhash::PyHash> {
         pyhash::hash_iter(self.elements.iter(), vm)
     }
@@ -285,6 +296,7 @@ If the argument is a tuple, the return value is the same object.";
         "__add__" => context.new_rustfunc(PyTupleRef::add),
         "__bool__" => context.new_rustfunc(PyTupleRef::bool),
         "__eq__" => context.new_rustfunc(PyTupleRef::eq),
+        "__ne__" => context.new_rustfunc(PyTupleRef::ne),
         "__contains__" => context.new_rustfunc(PyTupleRef::contains),
         "__getitem__" => context.new_rustfunc(PyTupleRef::getitem),
         "__hash__" => context.new_rustfunc(PyTupleRef::hash),
