Correctly wrap 'tp_iternext' slot.

Author: fangerer

graalpython/com.oracle.graal.python.cext/src/capi.h

@@ -295,6 +295,7 @@ void initialize_hashes();
 #define JWRAPPER_NE                          (polyglot_invoke(PY_TRUFFLE_CEXT, "METH_NE"))
 #define JWRAPPER_GT                          (polyglot_invoke(PY_TRUFFLE_CEXT, "METH_GT"))
 #define JWRAPPER_GE                          (polyglot_invoke(PY_TRUFFLE_CEXT, "METH_GE"))
+#define JWRAPPER_ITERNEXT                    (polyglot_invoke(PY_TRUFFLE_CEXT, "METH_ITERNEXT"))
 
 #define TDEBUG __builtin_debugtrap()
 #define get_method_flags_wrapper(flags)                                                  \

graalpython/com.oracle.graal.python.cext/src/typeobject.c

@@ -534,7 +534,7 @@ int PyType_Ready(PyTypeObject* cls) {
         ADD_SLOT_CONV("__ge__", NULL, cls->tp_richcompare, -2, JWRAPPER_GE);
     }
     ADD_SLOT("__iter__", cls->tp_iter, -1);
-    ADD_SLOT("__next__", cls->tp_iternext, -1);
+    ADD_SLOT_CONV("__next__", NULL, cls->tp_iternext, -1, JWRAPPER_ITERNEXT);
     ADD_SLOT("__get__", cls->tp_descr_get, -3);
     ADD_SLOT_PRIMITIVE("__set__", cls->tp_descr_set, -3);
     ADD_SLOT_PRIMITIVE("__init__", cls->tp_init, METH_KEYWORDS | METH_VARARGS);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ExternalFunctionNodes.java

@@ -225,6 +225,7 @@ public Node copy() {
         @TruffleBoundary
         ExternalFunctionInvokeNode() {
             this.toSulongNode = CExtNodes.AllToSulongNode.create();
+            this.checkResultNode = DefaultCheckFunctionResultNodeGen.create();
         }
 
         @TruffleBoundary
@@ -1002,6 +1003,31 @@ public Signature getSignature() {
         }
     }
 
+    /**
+     * Wrapper root node for C function type {@code iternextfunc}.
+     */
+    static class IterNextFuncRootNode extends MethodDescriptorRoot {
+
+        IterNextFuncRootNode(PythonLanguage language, String name, Object callable) {
+            super(language, name, callable);
+        }
+
+        IterNextFuncRootNode(PythonLanguage language, String name, Object callable, PExternalFunctionWrapper provider) {
+            super(language, name, callable, provider);
+        }
+
+        @Override
+        protected Object[] prepareCArguments(VirtualFrame frame) {
+            return new Object[]{readSelfNode.execute(frame)};
+        }
+
+        @Override
+        public Signature getSignature() {
+            // same signature as a method without arguments (just the self)
+            return MethNoargsRoot.SIGNATURE;
+        }
+    }
+
     /**
      * We need to inflate all primitives in order to avoid memory leaks. Explanation: Primitives
      * would currently be wrapped into a PrimitiveNativeWrapper. If any of those will receive a

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PythonCextBuiltins.java

@@ -71,6 +71,7 @@
 import com.oracle.graal.python.builtins.modules.BuiltinConstructors.IntNode;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.AllocFuncRootNode;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.GetAttrFuncRootNode;
+import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.IterNextFuncRootNode;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.MethDirectRoot;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.MethFastcallRoot;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.MethFastcallWithKeywordsRoot;
@@ -85,6 +86,7 @@
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.RichCmpFuncRootNode;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.SSizeObjArgProcRootNode;
 import com.oracle.graal.python.builtins.modules.ExternalFunctionNodes.SetAttrFuncRootNode;
+import com.oracle.graal.python.builtins.modules.PythonCextBuiltinsFactory.CheckIterNextResultNodeGen;
 import com.oracle.graal.python.builtins.modules.PythonCextBuiltinsFactory.DefaultCheckFunctionResultNodeGen;
 import com.oracle.graal.python.builtins.modules.PythonCextBuiltinsFactory.GetByteArrayNodeGen;
 import com.oracle.graal.python.builtins.objects.PNone;
@@ -827,7 +829,6 @@ abstract static class PyTruffleGetInheritedNativeSlots extends NativeBuiltin {
          * custom slots at a time where the C API is not yet loaded. So we need to check if any of
          * the base classes defines custom slots and adapt the basicsize to allocate space for the
          * slots and add the native member slot descriptors.
-         *
          */
         @Specialization
         Object slots(Object module, Object pythonClass, String subKey,
@@ -990,6 +991,31 @@ protected static boolean isPythonObjectNativeWrapper(Object object) {
         }
     }
 
+    // equivalent to result processing done in 'wrap_next' in 'Objects/typeobject.c'
+    abstract static class CheckIterNextResultNode extends CheckFunctionResultNode {
+
+        @Specialization(limit = "3")
+        static Object doGeneric(String name, Object result,
+                        @CachedLibrary("result") InteropLibrary lib,
+                        @CachedContext(PythonLanguage.class) ContextReference<PythonContext> contextRef,
+                        @Cached PRaiseNode raiseNode) {
+            if (lib.isNull(result)) {
+                PythonContext context = contextRef.get();
+                PException currentException = context.getCurrentException();
+                // if no exception occurred, the iterator is exhausted -> raise StopIteration
+                if (currentException == null) {
+                    throw raiseNode.raise(PythonBuiltinClassType.StopIteration);
+                } else {
+                    // consume exception
+                    context.setCurrentException(null);
+                    // re-raise exception
+                    throw currentException.getExceptionForReraise();
+                }
+            }
+            return result;
+        }
+    }
+
     @Builtin(name = "Py_NoValue")
     @GenerateNodeFactory
     abstract static class Py_NoValue extends PythonBuiltinNode {
@@ -2062,6 +2088,28 @@ protected MethGeNode() {
         }
     }
 
+    @Builtin(name = "METH_ITERNEXT")
+    @GenerateNodeFactory
+    public abstract static class MethIterNextNode extends PythonBuiltinNode {
+        private static final PExternalFunctionWrapper METH_ITERNEXT_CONVERTER = new PExternalFunctionWrapper(AllToSulongNode::create, CheckIterNextResultNodeGen::create) {
+
+            @Override
+            @TruffleBoundary
+            protected RootCallTarget createCallTarget(PythonLanguage language, String name, Object callable, boolean doArgAndResultConversion) {
+                if (!doArgAndResultConversion) {
+                    return createCallTarget(new IterNextFuncRootNode(language, name, callable));
+                } else {
+                    return createCallTarget(new IterNextFuncRootNode(language, name, callable, this));
+                }
+            }
+        };
+
+        @Specialization
+        static PExternalFunctionWrapper call() {
+            return METH_ITERNEXT_CONVERTER;
+        }
+    }
+
     @Builtin(name = "PyTruffle_Bytes_EmptyWithCapacity", minNumOfPositionalArgs = 1)
     @GenerateNodeFactory
     abstract static class PyTruffle_Bytes_EmptyWithCapacity extends PythonUnaryBuiltinNode {