Fix foreign_number_list >/</... foreign_list

* The problem was BinaryComparisonNode was eagerly raising TypeError
  but here we want to try the reverse comparison and so need to return NotImplemented instead.

Author: eregon

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

@@ -1057,20 +1057,17 @@ def test_foreign_number_list(self):
 
         with self.assertRaisesRegex(TypeError, "'<' not supported between instances of 'ForeignList' and 'int'"):
             assert l < 4
+        with self.assertRaisesRegex(TypeError, "'<' not supported between instances of 'int' and 'ForeignList'"):
+            assert 4 < l
 
         assert l < n
-
-        # does not work because > resolves to ForeignNumberType.__gt__ which doesn't handle foreign list on LHS
-        with self.assertRaisesRegex(TypeError, "'>' not supported between instances of 'int' and 'ForeignList'"):
-            assert n > l
+        assert n > l
 
         l[0] = 100
         assert not l < n
-        with self.assertRaisesRegex(TypeError, "'>' not supported between instances of 'int' and 'ForeignList'"):
-            assert not n > l
+        assert not n > l
         assert l > n
-        with self.assertRaisesRegex(TypeError, "'<' not supported between instances of 'int' and 'ForeignList'"):
-            assert n < l
+        assert n < l
 
     def test_foreign_repl(self):
         from java.util.logging import LogRecord

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/foreign/ForeignNumberBuiltins.java

@@ -66,18 +66,19 @@
 import com.oracle.graal.python.builtins.objects.foreign.ForeignObjectBuiltins.NormalizeForeignForBinopNode;
 import com.oracle.graal.python.builtins.objects.ints.PInt;
 import com.oracle.graal.python.builtins.objects.object.ObjectNodes;
+import com.oracle.graal.python.builtins.objects.type.SpecialMethodSlot;
 import com.oracle.graal.python.builtins.objects.type.TpSlots;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotBinaryOp.BinaryOpBuiltinNode;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotInquiry.NbBoolBuiltinNode;
 import com.oracle.graal.python.lib.PyNumberAddNode;
 import com.oracle.graal.python.lib.PyNumberMultiplyNode;
 import com.oracle.graal.python.lib.PyObjectStrAsTruffleStringNode;
 import com.oracle.graal.python.nodes.PRaiseNode;
+import com.oracle.graal.python.nodes.call.special.LookupAndCallBinaryNode;
 import com.oracle.graal.python.nodes.expression.BinaryArithmetic;
 import com.oracle.graal.python.nodes.expression.BinaryArithmetic.BitAndNode;
 import com.oracle.graal.python.nodes.expression.BinaryArithmetic.BitOrNode;
 import com.oracle.graal.python.nodes.expression.BinaryArithmetic.BitXorNode;
-import com.oracle.graal.python.nodes.expression.BinaryComparisonNode;
 import com.oracle.graal.python.nodes.expression.BinaryOpNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
@@ -381,10 +382,10 @@ abstract static class RDivModNode extends ForeignBinaryNode {
     }
 
     public abstract static class ForeignBinaryComparisonNode extends PythonBinaryBuiltinNode {
-        @Child private BinaryComparisonNode comparisonNode;
+        @Child private LookupAndCallBinaryNode comparisonNode;
 
-        protected ForeignBinaryComparisonNode(BinaryComparisonNode op) {
-            this.comparisonNode = op;
+        protected ForeignBinaryComparisonNode(SpecialMethodSlot slot, SpecialMethodSlot rslot) {
+            comparisonNode = LookupAndCallBinaryNode.create(slot, rslot, true, true);
         }
 
         @Specialization(guards = {"lib.isBoolean(left)"})
@@ -493,39 +494,39 @@ public static PNotImplemented doGeneric(Object left, Object right) {
     @GenerateNodeFactory
     public abstract static class LtNode extends ForeignBinaryComparisonNode {
         protected LtNode() {
-            super(BinaryComparisonNode.LtNode.create());
+            super(SpecialMethodSlot.Lt, SpecialMethodSlot.Gt);
         }
     }
 
     @Builtin(name = J___LE__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     public abstract static class LeNode extends ForeignBinaryComparisonNode {
         protected LeNode() {
-            super(BinaryComparisonNode.LeNode.create());
+            super(SpecialMethodSlot.Le, SpecialMethodSlot.Ge);
         }
     }
 
     @Builtin(name = J___GT__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     public abstract static class GtNode extends ForeignBinaryComparisonNode {
         protected GtNode() {
-            super(BinaryComparisonNode.GtNode.create());
+            super(SpecialMethodSlot.Gt, SpecialMethodSlot.Lt);
         }
     }
 
     @Builtin(name = J___GE__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     public abstract static class GeNode extends ForeignBinaryComparisonNode {
         protected GeNode() {
-            super(BinaryComparisonNode.GeNode.create());
+            super(SpecialMethodSlot.Ge, SpecialMethodSlot.Le);
         }
     }
 
     @Builtin(name = J___EQ__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     public abstract static class EqNode extends ForeignBinaryComparisonNode {
         protected EqNode() {
-            super(BinaryComparisonNode.EqNode.create());
+            super(SpecialMethodSlot.Eq, SpecialMethodSlot.Eq);
         }
     }