Refactoring of object.__ne__.

Author: ppisl

graalpython/com.oracle.graal.python.test/src/tests/test_compare.py

@@ -7,6 +7,20 @@
 
 import sys
 
+class Empty:
+    def __repr__(self):
+        return '<Empty>'
+
+class Cmp:
+    def __init__(self,arg):
+        self.arg = arg
+
+    def __repr__(self):
+        return '<Cmp %s>' % self.arg
+
+    def __eq__(self, other):
+        return self.arg == other
+
 class First():
 
     def __init__(self, value):
@@ -17,6 +31,28 @@ def __eq__(self, other):
 
 class BasicComparisonTest(unittest.TestCase):
 
+    set1 = [2, 2.0, 2, 2+0j, Cmp(2.0)]
+    set2 = [[1], (3,), None, Empty()]
+    candidates = set1 + set2
+
+    def test_comparisons(self):
+        for a in self.candidates:
+            for b in self.candidates:
+                if ((a in self.set1) and (b in self.set1)) or a is b:
+                    self.assertEqual(a, b)
+                else:
+                    self.assertNotEqual(a, b)
+
+    def test_id_comparisons(self):
+        # Ensure default comparison compares id() of args
+        L = []
+        for i in range(10):
+            L.insert(len(L)//2, Empty())
+        for a in L:
+            for b in L:
+                self.assertEqual(a == b, id(a) == id(b),
+                                 'a=%r, b=%r' % (a, b))
+
     def test_ne(self):
         x = First(1)
         y = First(1)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/CExtNodes.java

@@ -879,6 +879,10 @@ private TruffleObject getNativeFunction() {
             return isFunc;
         }
 
+        public static IsNode create() {
+            return new CExtNodes.IsNode();
+        }
+
     }
 
     public abstract static class AllToJavaNode extends PNodeWithContext {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/complex/ComplexBuiltins.java

@@ -367,12 +367,41 @@ PNotImplemented doComplex(Object left, Object right) {
 
     @GenerateNodeFactory
     @Builtin(name = __EQ__, fixedNumOfPositionalArgs = 2)
+    @TypeSystemReference(PythonArithmeticTypes.class)
     static abstract class EqNode extends PythonBinaryBuiltinNode {
         @Specialization
         boolean doComplex(PComplex left, PComplex right) {
             return left.equals(right);
         }
 
+        @Specialization
+        boolean doComplexInt(PComplex left, long right) {
+            if (left.getImag() == 0) {
+                return left.getReal() == right;
+            }
+            return false;
+        }
+
+        @Specialization
+        boolean doComplexInt(PComplex left, PInt right) {
+            if (left.getImag() == 0) {
+                try {
+                    return left.getReal() == right.getValue().longValueExact();
+                } catch (ArithmeticException e) {
+                    // do nothing -> return false;
+                }
+            }
+            return false;
+        }
+
+        @Specialization
+        boolean doComplexInt(PComplex left, double right) {
+            if (left.getImag() == 0) {
+                return left.getReal() == right;
+            }
+            return false;
+        }
+
         @SuppressWarnings("unused")
         @Fallback
         PNotImplemented doGeneric(Object left, Object right) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/object/ObjectBuiltins.java

@@ -54,9 +54,9 @@
 import com.oracle.graal.python.builtins.CoreFunctions;
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.PythonBuiltins;
-import com.oracle.graal.python.builtins.modules.BuiltinConstructors;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.PNotImplemented;
+import com.oracle.graal.python.builtins.objects.cext.CExtNodes;
 import com.oracle.graal.python.builtins.objects.cext.PythonNativeClass;
 import com.oracle.graal.python.builtins.objects.cext.PythonNativeObject;
 import com.oracle.graal.python.builtins.objects.common.PHashingCollection;
@@ -186,12 +186,14 @@ public int hash(Object self) {
     @GenerateNodeFactory
     public abstract static class EqNode extends PythonBinaryBuiltinNode {
         @Specialization
-        public boolean eq(PythonNativeObject self, PythonNativeObject other) {
-            return self.object.equals(other.object);
+        @TruffleBoundary
+        public boolean eq(PythonNativeObject self, PythonNativeObject other,
+                        @Cached("create()") CExtNodes.IsNode nativeIsNode) {
+            return nativeIsNode.execute(self, other);
         }
 
-        @Specialization
-        public boolean eq(Object self, Object other) {
+        @Fallback
+        public Object eq(Object self, Object other) {
             return self == other;
         }
     }
@@ -200,20 +202,30 @@ public boolean eq(Object self, Object other) {
     @GenerateNodeFactory
     public abstract static class NeNode extends PythonBinaryBuiltinNode {
 
+        @Child private LookupAndCallBinaryNode eqNode;
+        @Child private CastToBooleanNode ifFalseNode;
+
         @Specialization
         @TruffleBoundary
-        public boolean ne(PythonNativeObject self, PythonNativeObject other) {
-            return !self.object.equals(other.object);
+        public boolean ne(PythonNativeObject self, PythonNativeObject other,
+                        @Cached("create()") CExtNodes.IsNode nativeIsNode) {
+            return !nativeIsNode.execute(self, other);
         }
 
-        @Specialization
-        public Object ne(Object self, Object other,
-                        @Cached("create(__EQ__)") LookupAndCallBinaryNode eqNode,
-                        @Cached("createIfFalseNode()") CastToBooleanNode ifFalseNode) {
+        @Fallback
+        public Object ne(Object self, Object other) {
+            if (eqNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                eqNode = insert(LookupAndCallBinaryNode.create(__EQ__));
+            }
             Object result = eqNode.executeObject(self, other);
             if (result == PNotImplemented.NOT_IMPLEMENTED) {
                 return result;
             }
+            if (ifFalseNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                ifFalseNode = insert(CastToBooleanNode.createIfFalseNode());
+            }
             return ifFalseNode.executeWith(result);
         }
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/expression/IsNode.java

@@ -163,13 +163,9 @@ boolean doDD(double left, double right) {
         return left == right;
     }
 
-    protected static CExtNodes.IsNode getNativeIsNode() {
-        return new CExtNodes.IsNode();
-    }
-
     @Specialization
     boolean doNative(PythonNativeObject left, PythonNativeObject right,
-                    @Cached("getNativeIsNode()") CExtNodes.IsNode isNode) {
+                    @Cached("create()") CExtNodes.IsNode isNode) {
         return isNode.execute(left, right);
     }