Implement missing __divmod__ operations

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/floats/FloatBuiltins.java

@@ -25,12 +25,13 @@
  */
 package com.oracle.graal.python.builtins.objects.floats;
 
-import static com.oracle.graal.python.builtins.PythonBuiltinClassType.TypeError;
 import static com.oracle.graal.python.builtins.PythonBuiltinClassType.OverflowError;
+import static com.oracle.graal.python.builtins.PythonBuiltinClassType.TypeError;
 import static com.oracle.graal.python.builtins.PythonBuiltinClassType.ValueError;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__ABS__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__ADD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__BOOL__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__DIVMOD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__EQ__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__FLOAT__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__FLOORDIV__;
@@ -48,6 +49,7 @@
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__POS__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__POW__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RADD__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__RDIVMOD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__REPR__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RFLOORDIV__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RMOD__;
@@ -598,6 +600,37 @@ PNotImplemented doGeneric(Object left, Object right) {
         }
     }
 
+    @Builtin(name = __RDIVMOD__, minNumOfPositionalArgs = 2, reverseOperation = true)
+    @Builtin(name = __DIVMOD__, minNumOfPositionalArgs = 2)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @GenerateNodeFactory
+    abstract static class DivModNode extends FloatBinaryBuiltinNode {
+        @Specialization
+        PTuple doDL(double left, long right) {
+            raiseDivisionByZero(right == 0);
+            return factory().createTuple(new Object[]{Math.floor(left / right), left % right});
+        }
+
+        @Specialization
+        PTuple doDD(double left, double right) {
+            raiseDivisionByZero(right == 0.0);
+            return factory().createTuple(new Object[]{Math.floor(left / right), left % right});
+        }
+
+        @Specialization
+        PTuple doLD(long left, double right) {
+            raiseDivisionByZero(right == 0.0);
+            return factory().createTuple(new Object[]{Math.floor(left / right), left % right});
+        }
+
+        @Specialization
+        PTuple doGeneric(VirtualFrame frame, Object left, Object right,
+                        @Cached FloorDivNode floorDivNode,
+                        @Cached ModNode modNode) {
+            return factory().createTuple(new Object[]{floorDivNode.execute(frame, left, right), modNode.execute(frame, left, right)});
+        }
+    }
+
     @Builtin(name = SpecialMethodNames.__HASH__, minNumOfPositionalArgs = 1)
     @GenerateNodeFactory
     @TypeSystemReference(PythonArithmeticTypes.class)

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

@@ -35,6 +35,7 @@
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DELATTR__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DELITEM__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DIR__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__DIVMOD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__EQ__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__FLOORDIV__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__GETATTR__;
@@ -50,6 +51,7 @@
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__NEW__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__NE__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RADD__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__RDIVMOD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__REPR__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RFLOORDIV__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RMUL__;
@@ -415,6 +417,22 @@ abstract static class RFloorDivNode extends ForeignBinaryNode {
         }
     }
 
+    @Builtin(name = __DIVMOD__, minNumOfPositionalArgs = 2)
+    @GenerateNodeFactory
+    abstract static class DivModNode extends ForeignBinaryNode {
+        DivModNode() {
+            super(BinaryArithmetic.DivMod.create(), false);
+        }
+    }
+
+    @Builtin(name = __RDIVMOD__, minNumOfPositionalArgs = 2)
+    @GenerateNodeFactory
+    abstract static class RDivModNode extends ForeignBinaryNode {
+        RDivModNode() {
+            super(BinaryArithmetic.DivMod.create(), true);
+        }
+    }
+
     public abstract static class ForeignBinaryComparisonNode extends PythonBinaryBuiltinNode {
         @Child private BinaryComparisonNode comparisonNode;
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/ints/IntBuiltins.java

@@ -490,6 +490,31 @@ PNotImplemented doGeneric(Object right, Object left) {
 
     }
 
+    @Builtin(name = SpecialMethodNames.__RDIVMOD__, minNumOfPositionalArgs = 2, reverseOperation = true)
+    @Builtin(name = SpecialMethodNames.__DIVMOD__, minNumOfPositionalArgs = 2)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @GenerateNodeFactory
+    abstract static class DivModNode extends IntBinaryBuiltinNode {
+        @Specialization
+        PTuple doLL(int left, int right) {
+            raiseDivisionByZero(right == 0);
+            return factory().createTuple(new Object[]{Math.floorDiv(left, right), Math.floorMod(left, right)});
+        }
+
+        @Specialization
+        PTuple doLL(long left, long right) {
+            raiseDivisionByZero(right == 0);
+            return factory().createTuple(new Object[]{Math.floorDiv(left, right), Math.floorMod(left, right)});
+        }
+
+        @Specialization
+        PTuple doGeneric(VirtualFrame frame, Object left, Object right,
+                        @Cached FloorDivNode floorDivNode,
+                        @Cached ModNode modNode) {
+            return factory().createTuple(new Object[]{floorDivNode.execute(frame, left, right), modNode.execute(frame, left, right)});
+        }
+    }
+
     @Builtin(name = SpecialMethodNames.__MOD__, minNumOfPositionalArgs = 2)
     @TypeSystemReference(PythonArithmeticTypes.class)
     @GenerateNodeFactory

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

@@ -64,7 +64,8 @@ public enum BinaryArithmetic {
     Or(SpecialMethodNames.__OR__, "|"),
     Xor(SpecialMethodNames.__XOR__, "^"),
     MatMul(SpecialMethodNames.__MATMUL__, "@"),
-    Pow(SpecialMethodNames.__POW__, "**");
+    Pow(SpecialMethodNames.__POW__, "**"),
+    DivMod(SpecialMethodNames.__DIVMOD__, "divmod");
 
     private final String methodName;
     private final String reverseMethodName;