Add PRaiseNode#raiseExceptionObject and rename PRaiseNode.raiseExceptionObject to raiseExceptionObjectStatic

eregon · eregon · commit 249631a70e5f · 2025-07-21T13:37:27.000+02:00
* Fixes javac warnings about calling a static method on an instane.
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/CodecsModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/CodecsModuleBuiltins.java
@@ -250,7 +250,7 @@ static void handle(Node inliningTarget, TruffleEncoder encoder, TruffleString er
                 int end = start + encoder.getErrorLength();
                 Object exception = lazyCallNode.executeWithoutFrame(UnicodeEncodeError, encoder.getEncodingName(), inputObject, start, end, encoder.getErrorReason());
                 if (exception instanceof PBaseException) {
-                    throw raiseNode.raiseExceptionObject(inliningTarget, (PBaseException) exception);
+                    throw raiseNode.raiseExceptionObject(inliningTarget, exception);
                 } else {
                     // Shouldn't happen unless the user manually replaces the method, which is
                     // really
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/SREModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/SREModuleBuiltins.java
@@ -423,7 +423,7 @@ private RuntimeException handleCompilationError(Node node, RuntimeException e, I
                             PythonModule module = context.lookupBuiltinModule(BuiltinNames.T__SRE);
                             Object errorConstructor = PyObjectLookupAttr.executeUncached(module, T_ERROR);
                             PBaseException exception = (PBaseException) CallNode.executeUncached(errorConstructor, reason, originalPattern, position);
-                            return PRaiseNode.raiseExceptionObject(node, exception);
+                            return PRaiseNode.raiseExceptionObjectStatic(node, exception);
                         }
                     }
                 }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/WarningsModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/WarningsModuleBuiltins.java
@@ -834,7 +834,7 @@ private void warnExplicitPart2(PythonContext context, PythonModule warnings, Tru
                 if (!PyExceptionInstanceCheckNode.executeUncached(message)) {
                     throw PRaiseNode.raiseStatic(this, PythonBuiltinClassType.SystemError, ErrorMessages.EXCEPTION_NOT_BASEEXCEPTION, PyObjectReprAsTruffleStringNode.executeUncached(message));
                 } else {
-                    throw PRaiseNode.raiseExceptionObject(this, message);
+                    throw PRaiseNode.raiseExceptionObjectStatic(this, message);
                 }
             }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextErrBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextErrBuiltins.java
@@ -209,7 +209,7 @@ static Object create(Object type, Object value,
                         @SuppressWarnings("unused") @Shared @Cached IsSubClassNode isSubClassNode,
                         @Cached PrepareExceptionNode prepareExceptionNode) {
             Object exception = prepareExceptionNode.execute(null, type, value);
-            throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);
+            throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);
         }
 
         protected static boolean isExceptionClass(Node inliningTarget, Object obj, IsTypeNode isTypeNode, IsSubClassNode isSubClassNode) {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextPyStateBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextPyStateBuiltins.java
@@ -182,15 +182,15 @@ int doIt(long id, Object exceptionObject) {
                         @Override
                         protected void perform(Access access) {
                             if (missedCount == MAX_MISSED_COUNT) {
-                                throw PRaiseNode.raiseExceptionObject(null, exceptionObject);
+                                throw PRaiseNode.raiseExceptionObjectStatic(null, exceptionObject);
                             }
                             // If possible, we do not want to raise in some internal code, it could
                             // corrupt internal data structures.
                             Node location = access.getLocation();
                             if (location != null) {
                                 RootNode rootNode = location.getRootNode();
                                 if (rootNode instanceof PRootNode && !rootNode.isInternal()) {
-                                    throw PRaiseNode.raiseExceptionObject(null, exceptionObject);
+                                    throw PRaiseNode.raiseExceptionObjectStatic(null, exceptionObject);
                                 }
                             }
                             // Heuristic fabricated out of thin air:
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/codecs/ErrorHandlers.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/codecs/ErrorHandlers.java
@@ -269,7 +269,7 @@ abstract static class StrictErrorHandlerNode extends ErrorHandlerBaseNode {
         @Specialization
         static Object doException(PBaseException exception,
                         @Bind Node inliningTarget) {
-            throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);
+            throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);
         }
 
         @Fallback
@@ -985,7 +985,7 @@ abstract static class RaiseEncodeException extends Node {
         static void doIt(VirtualFrame frame, Node inliningTarget, ErrorHandlerCache cache, TruffleString encoding, TruffleString srcObj, int startPos, int endPos, TruffleString reason,
                         @Cached MakeEncodeExceptionNode makeEncodeExceptionNode) {
             cache.exceptionObject = makeEncodeExceptionNode.execute(frame, inliningTarget, cache.exceptionObject, encoding, srcObj, startPos, endPos, reason);
-            PRaiseNode.raiseExceptionObject(inliningTarget, cache.exceptionObject);
+            PRaiseNode.raiseExceptionObjectStatic(inliningTarget, cache.exceptionObject);
         }
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/io/AbstractBufferedIOBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/io/AbstractBufferedIOBuiltins.java
@@ -231,7 +231,7 @@ static PException raise(Node node, Object errno, TruffleString message, int writ
             attrs[OsErrorBuiltins.IDX_STRERROR] = message;
             attrs[OsErrorBuiltins.IDX_WRITTEN] = written;
             exception.setExceptionAttributes(attrs);
-            return PRaiseNode.raiseExceptionObject(node, exception);
+            return PRaiseNode.raiseExceptionObjectStatic(node, exception);
         }
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/json/JSONScannerBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/json/JSONScannerBuiltins.java
@@ -549,12 +549,12 @@ private static RuntimeException decodeError(Node raisingNode, String jsonString,
         Object module = AbstractImportNode.importModule(toTruffleStringUncached("json.decoder"));
         Object errorClass = PyObjectLookupAttr.executeUncached(module, T_JSON_DECODE_ERROR);
         Object exception = CallNode.executeUncached(errorClass, format, toTruffleStringUncached(jsonString), pos);
-        throw PRaiseNode.raiseExceptionObject(raisingNode, exception, false);
+        throw PRaiseNode.raiseExceptionObjectStatic(raisingNode, exception, false);
     }
 
     private static RuntimeException stopIteration(Node raisingNode, Object value) {
         CompilerAsserts.neverPartOfCompilation();
         Object exception = CallNode.executeUncached(PythonContext.get(raisingNode).lookupType(PythonBuiltinClassType.StopIteration), value);
-        throw PRaiseNode.raiseExceptionObject(raisingNode, exception, false);
+        throw PRaiseNode.raiseExceptionObjectStatic(raisingNode, exception, false);
     }
 }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/common/CExtCommonNodes.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/common/CExtCommonNodes.java
@@ -614,7 +614,7 @@ private static PException raiseResultWithError(Node node, TruffleString name, Ob
             PythonLanguage language = PythonLanguage.get(null);
             PBaseException sysExc = PFactory.createBaseException(language, SystemError, resultWithErrorMessage, new Object[]{name});
             sysExc.setCause(currentException);
-            throw PRaiseNode.raiseExceptionObject(node, sysExc, PythonOptions.isPExceptionWithJavaStacktrace(language));
+            throw PRaiseNode.raiseExceptionObjectStatic(node, sysExc, PythonOptions.isPExceptionWithJavaStacktrace(language));
         }
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/exception/PBaseException.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/exception/PBaseException.java
@@ -302,7 +302,7 @@ RuntimeException throwException(
                     @Shared("gil") @Cached GilNode gil) {
         boolean mustRelease = gil.acquire();
         try {
-            throw PRaiseNode.raiseExceptionObject(node, this);
+            throw PRaiseNode.raiseExceptionObjectStatic(node, this);
         } finally {
             gil.release(mustRelease);
         }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PConstructAndRaiseNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PConstructAndRaiseNode.java
@@ -108,7 +108,7 @@ private PException raiseInternal(VirtualFrame frame, PythonBuiltinClassType type
             error.setContext(cause);
             error.setCause(cause);
         }
-        return PRaiseNode.raiseExceptionObject(this, error);
+        return PRaiseNode.raiseExceptionObjectStatic(this, error);
     }
 
     @Specialization(guards = {"format == null", "formatArgs == null"})
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PRaiseNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PRaiseNode.java
@@ -83,7 +83,7 @@ public final PException raise(Node inliningTarget, PythonBuiltinClassType type)
     public static PException raiseStatic(Node node, PythonBuiltinClassType type) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raise(Node inliningTarget, PythonBuiltinClassType type, TruffleString message) {
@@ -94,7 +94,7 @@ public final PException raise(Node inliningTarget, PythonBuiltinClassType type,
     public static PException raiseStatic(Node node, PythonBuiltinClassType type, TruffleString message) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, message);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raise(Node inliningTarget, PythonBuiltinClassType type, TruffleString format, Object... formatArgs) {
@@ -105,7 +105,7 @@ public final PException raise(Node inliningTarget, PythonBuiltinClassType type,
     public static PException raiseStatic(Node node, PythonBuiltinClassType type, TruffleString message, Object... formatArgs) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, message, formatArgs);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raise(Node inliningTarget, PythonBuiltinClassType type, Object[] arguments) {
@@ -116,7 +116,7 @@ public final PException raise(Node inliningTarget, PythonBuiltinClassType type,
     public static PException raiseStatic(Node node, PythonBuiltinClassType type, Object[] arguments) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, PFactory.createTuple(language, arguments));
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raiseWithData(Node inliningTarget, PythonBuiltinClassType type, Object[] data) {
@@ -127,7 +127,7 @@ public final PException raiseWithData(Node inliningTarget, PythonBuiltinClassTyp
     public static PException raiseWithDataStatic(Node node, PythonBuiltinClassType type, Object[] data) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, data, null);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raiseAttributeError(Node inliningTarget, Object obj, Object key) {
@@ -147,7 +147,7 @@ public final PException raiseWithData(Node inliningTarget, PythonBuiltinClassTyp
     public static PException raiseWithDataStatic(Node node, PythonBuiltinClassType type, Object[] data, TruffleString format, Object... formatArgs) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, data, format, formatArgs);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raiseWithData(Node inliningTarget, PythonBuiltinClassType type, Object[] data, Object... arguments) {
@@ -158,7 +158,7 @@ public final PException raiseWithData(Node inliningTarget, PythonBuiltinClassTyp
     public static PException raiseWithDataStatic(Node node, PythonBuiltinClassType type, Object[] data, Object[] arguments) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, data, PFactory.createTuple(language, arguments));
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raise(Node inliningTarget, PythonBuiltinClassType type, Exception e) {
@@ -169,7 +169,7 @@ public final PException raise(Node inliningTarget, PythonBuiltinClassType type,
     public static PException raiseStatic(Node node, PythonBuiltinClassType type, Exception e) {
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, ErrorMessages.M, new Object[]{e});
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     private static void setCause(PBaseException pythonException, PException cause) {
@@ -188,7 +188,7 @@ public static PException raiseWithCauseStatic(Node node, PythonBuiltinClassType
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, format);
         setCause(pythonException, cause);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raiseWithCause(Node inliningTarget, PythonBuiltinClassType type, PException cause, TruffleString format, Object... arguments) {
@@ -202,7 +202,7 @@ public static PException raiseWithCauseStatic(Node node, PythonBuiltinClassType
         PythonLanguage language = PythonLanguage.get(node);
         PBaseException pythonException = PFactory.createBaseException(language, type, format, formatArgs);
         setCause(pythonException, cause);
-        throw raiseExceptionObject(node, pythonException, language);
+        throw raiseExceptionObjectStatic(node, pythonException, language);
     }
 
     public final PException raiseOverflow(Node inliningTarget) {
@@ -229,15 +229,19 @@ public final PException raiseBadInternalCall(Node inliningTarget) {
         throw raise(inliningTarget, PythonBuiltinClassType.SystemError, BAD_ARG_TO_INTERNAL_FUNC);
     }
 
-    public static PException raiseExceptionObject(Node raisingNode, Object exc) {
-        throw raiseExceptionObject(raisingNode, exc, PythonOptions.isPExceptionWithJavaStacktrace(PythonLanguage.get(raisingNode)));
+    public final PException raiseExceptionObject(Node raisingNode, Object exc) {
+        throw raiseExceptionObjectStatic(raisingNode, exc);
     }
 
-    public static PException raiseExceptionObject(Node raisingNode, Object exc, PythonLanguage language) {
-        throw raiseExceptionObject(raisingNode, exc, PythonOptions.isPExceptionWithJavaStacktrace(language));
+    public static PException raiseExceptionObjectStatic(Node raisingNode, Object exc) {
+        throw raiseExceptionObjectStatic(raisingNode, exc, PythonOptions.isPExceptionWithJavaStacktrace(PythonLanguage.get(raisingNode)));
     }
 
-    public static PException raiseExceptionObject(Node raisingNode, Object exc, boolean withJavaStacktrace) {
+    public static PException raiseExceptionObjectStatic(Node raisingNode, Object exc, PythonLanguage language) {
+        throw raiseExceptionObjectStatic(raisingNode, exc, PythonOptions.isPExceptionWithJavaStacktrace(language));
+    }
+
+    public static PException raiseExceptionObjectStatic(Node raisingNode, Object exc, boolean withJavaStacktrace) {
         if (raisingNode != null && raisingNode.isAdoptable()) {
             throw PException.fromObject(exc, raisingNode, withJavaStacktrace);
         } else {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/bytecode/RaiseNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/bytecode/RaiseNode.java
@@ -146,7 +146,7 @@ static void reraise(VirtualFrame frame, @SuppressWarnings("unused") PNone type,
     @Specialization(guards = "isNoValue(cause)")
     public static void doRaise(@SuppressWarnings("unused") VirtualFrame frame, PBaseException exception, @SuppressWarnings("unused") PNone cause, @SuppressWarnings("unused") boolean rootNodeVisible,
                     @Bind Node inliningTarget) {
-        throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);
+        throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);
     }
 
     // raise <native-exception>
@@ -155,7 +155,7 @@ public static void doRaiseNative(@SuppressWarnings("unused") VirtualFrame frame,
                     @SuppressWarnings("unused") boolean rootNodeVisible,
                     @Bind Node inliningTarget,
                     @SuppressWarnings("unused") @Shared @Cached PyExceptionInstanceCheckNode check) {
-        throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);
+        throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);
     }
 
     // raise <exception> from *
@@ -164,7 +164,7 @@ public static void doRaise(@SuppressWarnings("unused") VirtualFrame frame, PBase
                     @Bind Node inliningTarget,
                     @Shared @Cached SetExceptionCauseNode setExceptionCauseNode) {
         setExceptionCauseNode.execute(frame, exception, cause);
-        throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);
+        throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);
     }
 
     // raise <native-exception> from *
@@ -174,7 +174,7 @@ public static void doRaiseNative(@SuppressWarnings("unused") VirtualFrame frame,
                     @SuppressWarnings("unused") @Shared @Cached PyExceptionInstanceCheckNode check,
                     @Shared @Cached SetExceptionCauseNode setExceptionCauseNode) {
         setExceptionCauseNode.execute(frame, exception, cause);
-        throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);
+        throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);
     }
 
     private static void checkBaseClass(VirtualFrame frame, Node inliningTarget, Object pythonClass, ValidExceptionNode validException, PRaiseNode raise,
@@ -198,7 +198,7 @@ public static void doRaise(@SuppressWarnings("unused") VirtualFrame frame, Objec
         checkBaseClass(frame, inliningTarget, pythonClass, validException, raise, baseCheckFailedProfile);
         Object newException = callConstructor.execute(frame, pythonClass);
         if (check.execute(inliningTarget, newException)) {
-            throw PRaiseNode.raiseExceptionObject(inliningTarget, newException);
+            throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, newException);
         } else {
             throw raise.raise(inliningTarget, TypeError, ErrorMessages.SHOULD_HAVE_RETURNED_EXCEPTION, pythonClass, newException);
         }
@@ -219,7 +219,7 @@ public static void doRaise(@SuppressWarnings("unused") VirtualFrame frame, Objec
         Object newException = callConstructor.execute(frame, pythonClass);
         if (check.execute(inliningTarget, newException)) {
             setExceptionCauseNode.execute(frame, newException, cause);
-            throw PRaiseNode.raiseExceptionObject(inliningTarget, newException);
+            throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, newException);
         } else {
             throw raise.raise(inliningTarget, TypeError, ErrorMessages.SHOULD_HAVE_RETURNED_EXCEPTION, pythonClass, newException);
         }

Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,7 @@ private RuntimeException handleCompilationError(Node node, RuntimeException e, I`
`423`	`423`	`PythonModule module = context.lookupBuiltinModule(BuiltinNames.T__SRE);`
`424`	`424`	`Object errorConstructor = PyObjectLookupAttr.executeUncached(module, T_ERROR);`
`425`	`425`	`PBaseException exception = (PBaseException) CallNode.executeUncached(errorConstructor, reason, originalPattern, position);`
`426`		`- return PRaiseNode.raiseExceptionObject(node, exception);`
	`426`	`+ return PRaiseNode.raiseExceptionObjectStatic(node, exception);`
`427`	`427`	`}`
`428`	`428`	`}`
`429`	`429`	`}`
Original file line number	Diff line number	Diff line change
`@@ -834,7 +834,7 @@ private void warnExplicitPart2(PythonContext context, PythonModule warnings, Tru`
`834`	`834`	`if (!PyExceptionInstanceCheckNode.executeUncached(message)) {`
`835`	`835`	`throw PRaiseNode.raiseStatic(this, PythonBuiltinClassType.SystemError, ErrorMessages.EXCEPTION_NOT_BASEEXCEPTION, PyObjectReprAsTruffleStringNode.executeUncached(message));`
`836`	`836`	`} else {`
`837`		`- throw PRaiseNode.raiseExceptionObject(this, message);`
	`837`	`+ throw PRaiseNode.raiseExceptionObjectStatic(this, message);`
`838`	`838`	`}`
`839`	`839`	`}`
`840`	`840`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ static Object create(Object type, Object value,`
`209`	`209`	`@SuppressWarnings("unused") @Shared @Cached IsSubClassNode isSubClassNode,`
`210`	`210`	`@Cached PrepareExceptionNode prepareExceptionNode) {`
`211`	`211`	`Object exception = prepareExceptionNode.execute(null, type, value);`
`212`		`- throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);`
	`212`	`+ throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`protected static boolean isExceptionClass(Node inliningTarget, Object obj, IsTypeNode isTypeNode, IsSubClassNode isSubClassNode) {`
Original file line number	Diff line number	Diff line change
`@@ -182,15 +182,15 @@ int doIt(long id, Object exceptionObject) {`
`182`	`182`	`@Override`
`183`	`183`	`protected void perform(Access access) {`
`184`	`184`	`if (missedCount == MAX_MISSED_COUNT) {`
`185`		`- throw PRaiseNode.raiseExceptionObject(null, exceptionObject);`
	`185`	`+ throw PRaiseNode.raiseExceptionObjectStatic(null, exceptionObject);`
`186`	`186`	`}`
`187`	`187`	`// If possible, we do not want to raise in some internal code, it could`
`188`	`188`	`// corrupt internal data structures.`
`189`	`189`	`Node location = access.getLocation();`
`190`	`190`	`if (location != null) {`
`191`	`191`	`RootNode rootNode = location.getRootNode();`
`192`	`192`	`if (rootNode instanceof PRootNode && !rootNode.isInternal()) {`
`193`		`- throw PRaiseNode.raiseExceptionObject(null, exceptionObject);`
	`193`	`+ throw PRaiseNode.raiseExceptionObjectStatic(null, exceptionObject);`
`194`	`194`	`}`
`195`	`195`	`}`
`196`	`196`	`// Heuristic fabricated out of thin air:`
Original file line number	Diff line number	Diff line change
`@@ -269,7 +269,7 @@ abstract static class StrictErrorHandlerNode extends ErrorHandlerBaseNode {`
`269`	`269`	`@Specialization`
`270`	`270`	`static Object doException(PBaseException exception,`
`271`	`271`	`@Bind Node inliningTarget) {`
`272`		`- throw PRaiseNode.raiseExceptionObject(inliningTarget, exception);`
	`272`	`+ throw PRaiseNode.raiseExceptionObjectStatic(inliningTarget, exception);`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`@Fallback`
`@@ -985,7 +985,7 @@ abstract static class RaiseEncodeException extends Node {`
`985`	`985`	`static void doIt(VirtualFrame frame, Node inliningTarget, ErrorHandlerCache cache, TruffleString encoding, TruffleString srcObj, int startPos, int endPos, TruffleString reason,`
`986`	`986`	`@Cached MakeEncodeExceptionNode makeEncodeExceptionNode) {`
`987`	`987`	`cache.exceptionObject = makeEncodeExceptionNode.execute(frame, inliningTarget, cache.exceptionObject, encoding, srcObj, startPos, endPos, reason);`
`988`		`- PRaiseNode.raiseExceptionObject(inliningTarget, cache.exceptionObject);`
	`988`	`+ PRaiseNode.raiseExceptionObjectStatic(inliningTarget, cache.exceptionObject);`
`989`	`989`	`}`
`990`	`990`	`}`
`991`	`991`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ static PException raise(Node node, Object errno, TruffleString message, int writ`
`231`	`231`	`attrs[OsErrorBuiltins.IDX_STRERROR] = message;`
`232`	`232`	`attrs[OsErrorBuiltins.IDX_WRITTEN] = written;`
`233`	`233`	`exception.setExceptionAttributes(attrs);`
`234`		`- return PRaiseNode.raiseExceptionObject(node, exception);`
	`234`	`+ return PRaiseNode.raiseExceptionObjectStatic(node, exception);`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -549,12 +549,12 @@ private static RuntimeException decodeError(Node raisingNode, String jsonString,`
`549`	`549`	`Object module = AbstractImportNode.importModule(toTruffleStringUncached("json.decoder"));`
`550`	`550`	`Object errorClass = PyObjectLookupAttr.executeUncached(module, T_JSON_DECODE_ERROR);`
`551`	`551`	`Object exception = CallNode.executeUncached(errorClass, format, toTruffleStringUncached(jsonString), pos);`
`552`		`- throw PRaiseNode.raiseExceptionObject(raisingNode, exception, false);`
	`552`	`+ throw PRaiseNode.raiseExceptionObjectStatic(raisingNode, exception, false);`
`553`	`553`	`}`
`554`	`554`
`555`	`555`	`private static RuntimeException stopIteration(Node raisingNode, Object value) {`
`556`	`556`	`CompilerAsserts.neverPartOfCompilation();`
`557`	`557`	`Object exception = CallNode.executeUncached(PythonContext.get(raisingNode).lookupType(PythonBuiltinClassType.StopIteration), value);`
`558`		`- throw PRaiseNode.raiseExceptionObject(raisingNode, exception, false);`
	`558`	`+ throw PRaiseNode.raiseExceptionObjectStatic(raisingNode, exception, false);`
`559`	`559`	`}`
`560`	`560`	`}`
Original file line number	Diff line number	Diff line change
`@@ -614,7 +614,7 @@ private static PException raiseResultWithError(Node node, TruffleString name, Ob`
`614`	`614`	`PythonLanguage language = PythonLanguage.get(null);`
`615`	`615`	`PBaseException sysExc = PFactory.createBaseException(language, SystemError, resultWithErrorMessage, new Object[]{name});`
`616`	`616`	`sysExc.setCause(currentException);`
`617`		`- throw PRaiseNode.raiseExceptionObject(node, sysExc, PythonOptions.isPExceptionWithJavaStacktrace(language));`
	`617`	`+ throw PRaiseNode.raiseExceptionObjectStatic(node, sysExc, PythonOptions.isPExceptionWithJavaStacktrace(language));`
`618`	`618`	`}`
`619`	`619`	`}`
`620`	`620`
Original file line number	Diff line number	Diff line change
`@@ -302,7 +302,7 @@ RuntimeException throwException(`
`302`	`302`	`@Shared("gil") @Cached GilNode gil) {`
`303`	`303`	`boolean mustRelease = gil.acquire();`
`304`	`304`	`try {`
`305`		`- throw PRaiseNode.raiseExceptionObject(node, this);`
	`305`	`+ throw PRaiseNode.raiseExceptionObjectStatic(node, this);`
`306`	`306`	`} finally {`
`307`	`307`	`gil.release(mustRelease);`
`308`	`308`	`}`