Introduce record ExceptionState

Author: fangerer

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextErrBuiltins.java

@@ -83,6 +83,7 @@
 import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiUnaryBuiltinNode;
 import com.oracle.graal.python.builtins.modules.cext.PythonCextFileBuiltins.PyFile_WriteObject;
 import com.oracle.graal.python.builtins.objects.PNone;
+import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.ExceptionState;
 import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.PyErrFetchNode;
 import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.PyErrOccurredNode;
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.NativeToPythonNode;
@@ -203,28 +204,26 @@ static Object doGeneric(Object pType, Object pValue, Object pTraceback,
                         @Cached PythonToNativeNewRefNode toNativeNewRefNode,
                         @Cached CStructAccess.WritePointerNode writePointerNode) {
             PythonContext.PythonThreadState threadState = getThreadStateNode.execute(inliningTarget);
-            Object[] exceptionState = pyErrFetchNode.execute(inliningTarget, threadState);
-            // null or [type, value, traceback]
-            assert exceptionState == null || exceptionState.length == 3;
+            ExceptionState exceptionState = pyErrFetchNode.execute(inliningTarget, threadState);
             if (exceptionState == null) {
                 /*
                  * This should be caught in native by checking 'PyErr_Occurred' and avoiding the
                  * upcall. But let's be defensive and treat that case on a slow path.
                  */
                 doNoException(pType, pValue, pTraceback);
             } else {
-                assert exceptionState[0] != null;
-                assert exceptionState[1] != null;
+                assert exceptionState.type() != null;
+                assert exceptionState.value() != null;
                 /*
                  * NOTE: We cannot use 'WriteObjectNewRefNode' because we are writing to out
                  * variables (C type 'PyObject **out') where the previous value (i.e. '*out') of
                  * those is unspecified. 'WriteObjectNewRefNode' would try to decref the previous
                  * object and we MUST NOT do that. Therefore, we use the combination of
                  * 'WritePointerNode' and 'PythonToNativeNewRefNode'.
                  */
-                writePointerNode.write(pType, toNativeNewRefNode.execute(exceptionState[0]));
-                writePointerNode.write(pValue, toNativeNewRefNode.execute(exceptionState[1]));
-                writePointerNode.write(pTraceback, toNativeNewRefNode.execute(exceptionState[2] != null ? exceptionState[2] : PNone.NO_VALUE));
+                writePointerNode.write(pType, toNativeNewRefNode.execute(exceptionState.type()));
+                writePointerNode.write(pValue, toNativeNewRefNode.execute(exceptionState.value()));
+                writePointerNode.write(pTraceback, toNativeNewRefNode.execute(exceptionState.traceback() != null ? exceptionState.traceback() : PNone.NO_VALUE));
             }
             return PNone.NO_VALUE;
         }
@@ -460,17 +459,15 @@ static Object raise(int set_sys_last_vars,
             if (err != nativeNull && IsBuiltinObjectProfile.profileObjectUncached(err, PythonBuiltinClassType.SystemExit)) {
                 handleSystemExit(excInfoNode, getItemNode, isInstanceNode, restoreNode, (SysModuleBuiltins) sys.getBuiltins(), writeFileNode, exitNode);
             }
-            Object[] fetched = PyErrFetchNode.executeUncached(threadState);
-            // null or [type, value, traceback]
-            assert fetched == null || fetched.length == 3;
+            ExceptionState fetched = PyErrFetchNode.executeUncached(threadState);
             Object type = null;
             Object val = null;
             Object tb = null;
 
             if (fetched != null) {
-                type = fetched[0];
-                val = fetched[1];
-                tb = fetched[2];
+                type = fetched.type();
+                val = fetched.value();
+                tb = fetched.traceback();
             }
             if (type == null || type == PNone.NONE) {
                 return PNone.NONE;

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

@@ -1017,19 +1017,22 @@ static Object doGeneric(Node inliningTarget, PythonThreadState threadState,
         }
     }
 
+    public record ExceptionState(Object type, Object value, Object traceback) {
+    }
+
     @GenerateInline
     @GenerateCached(false)
     @GenerateUncached
     public abstract static class PyErrFetchNode extends Node {
 
-        public static Object[] executeUncached(PythonThreadState threadState) {
+        public static ExceptionState executeUncached(PythonThreadState threadState) {
             return PyErrFetchNodeGen.getUncached().execute(null, threadState);
         }
 
-        public abstract Object[] execute(Node inliningTarget, PythonThreadState threadState);
+        public abstract ExceptionState execute(Node inliningTarget, PythonThreadState threadState);
 
         @Specialization
-        static Object[] doGeneric(Node inliningTarget, PythonThreadState threadState,
+        static ExceptionState doGeneric(Node inliningTarget, PythonThreadState threadState,
                         @Cached GetClassNode getClassNode,
                         @Cached MaterializeLazyTracebackNode materializeTraceback,
                         @Cached ClearCurrentExceptionNode clearCurrentExceptionNode) {
@@ -1047,7 +1050,7 @@ static Object[] doGeneric(Node inliningTarget, PythonThreadState threadState,
                 traceback = materializeTraceback.execute(inliningTarget, threadState.getCurrentTraceback());
             }
             clearCurrentExceptionNode.execute(inliningTarget, threadState);
-            return new Object[]{getClassNode.execute(inliningTarget, exception), exception, traceback};
+            return new ExceptionState(getClassNode.execute(inliningTarget, exception), exception, traceback);
         }
     }