Refactor getNode calls. For exceptions only called once in CallStackManager

horakivo · horakivo · commit 7a90daa58565 · 2023-06-26T15:07:23.000+02:00
diff --git a/src/main/java/org/truffleruby/cext/UnwrapNode.java b/src/main/java/org/truffleruby/cext/UnwrapNode.java
@@ -183,7 +183,7 @@ protected static ValueWrapper genericToWrapper(Node node, Object value,
             } catch (UnsupportedMessageException e) {
                 unsupportedProfile.enter(node);
                 throw new RaiseException(getContext(node),
-                        coreExceptions(node).argumentError(e.getMessage(), getNode(node), e));
+                        coreExceptions(node).argumentError(e.getMessage(), node, e));
             }
             return nativeToWrapperNode.execute(node, handle);
         }
@@ -281,7 +281,7 @@ protected static Object unwrapGeneric(Node node, Object value,
         } catch (UnsupportedMessageException e) {
             unsupportedProfile.enter(node);
             throw new RaiseException(getContext(node),
-                    coreExceptions(node).argumentError(e.getMessage(), getNode(node), e));
+                    coreExceptions(node).argumentError(e.getMessage(), node, e));
         }
         return unwrapNativeNode.execute(node, handle);
     }
diff --git a/src/main/java/org/truffleruby/cext/ValueWrapperManager.java b/src/main/java/org/truffleruby/cext/ValueWrapperManager.java
@@ -336,7 +336,7 @@ protected long allocateHandle(ValueWrapper wrapper, RubyContext context, RubyLan
             }
 
             if (context.getOptions().BACKTRACE_ON_TO_NATIVE) {
-                context.getDefaultBacktraceFormatter().printBacktraceOnEnvStderr("ValueWrapper#toNative: ", getNode());
+                context.getDefaultBacktraceFormatter().printBacktraceOnEnvStderr("ValueWrapper#toNative: ", this);
             }
 
             if (block == null || block.isFull()) {
diff --git a/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java b/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java
@@ -84,7 +84,7 @@ protected static String nameToJavaString(Object object,
             if (e.getException().getLogicalClass() == coreLibrary(node).noMethodErrorClass) {
                 throw new RaiseException(getContext(node), coreExceptions(node).typeError(
                         Utils.concat(object, " is not a symbol nor a string"),
-                        getNode(node)));
+                        node));
             } else {
                 throw e;
             }
@@ -99,7 +99,7 @@ protected static String nameToJavaString(Object object,
                     "String",
                     "to_str",
                     coerced,
-                    getNode(node)));
+                    node));
         }
     }
 
diff --git a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java
@@ -90,7 +90,7 @@ protected static RubySymbol toStr(Object object,
                     "String",
                     "to_str",
                     coerced,
-                    getNode(node)));
+                    node));
         }
     }
 
diff --git a/src/main/java/org/truffleruby/core/inlined/AlwaysInlinedMethodNode.java b/src/main/java/org/truffleruby/core/inlined/AlwaysInlinedMethodNode.java
@@ -41,7 +41,7 @@ public abstract class AlwaysInlinedMethodNode extends RubyBaseNode {
     public abstract Object execute(Frame callerFrame, Object self, Object[] rubyArgs, RootCallTarget target);
 
     protected void needCallerFrame(Frame callerFrame, RootCallTarget target) {
-        needCallerFrame(getNode(), callerFrame, target);
+        needCallerFrame(this, callerFrame, target);
     }
 
     protected static void needCallerFrame(Node node, Frame callerFrame, RootCallTarget target) {
@@ -56,7 +56,7 @@ protected static void needCallerFrame(Node node, Frame callerFrame, RootCallTarg
     protected void needCallerFrame(Frame callerFrame, String method) {
         if (callerFrame == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            throw buildException(getNode(), method);
+            throw buildException(this, method);
         }
 
         assert CallStackManager.isRubyFrame(callerFrame);
@@ -71,7 +71,7 @@ private static RaiseException buildException(Node node, RootCallTarget target) {
     private static RaiseException buildException(Node node, String method) {
         return new RaiseException(getContext(node), coreExceptions(node).runtimeError(
                 method + " needs the caller frame but it was not passed (cannot be called directly from a foreign language)",
-                getNode(node)));
+                node));
     }
 
     public static boolean isBlockProvided(Object[] rubyArgs) {
diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java
@@ -363,7 +363,7 @@ public abstract static class BindingNode extends AlwaysInlinedMethodNode {
         @Specialization
         protected RubyBinding binding(Frame callerFrame, Object self, Object[] rubyArgs, RootCallTarget target,
                 @Cached(
-                        value = "getNode().getEncapsulatingSourceSection()",
+                        value = "getNode(this).getEncapsulatingSourceSection()",
                         allowUncached = true, neverDefault = false) SourceSection sourceSection) {
             needCallerFrame(callerFrame, target);
             return BindingNodes.createBinding(getContext(), getLanguage(), callerFrame.materialize(), sourceSection);
@@ -700,7 +700,7 @@ protected Object eval(Frame callerFrame, Object callerSelf, Object[] rubyArgs, R
                     errorProfile.enter(this);
                     throw new RaiseException(
                             getContext(),
-                            coreExceptions().typeErrorWrongArgumentType(bindingArg, "binding", getNode()));
+                            coreExceptions().typeErrorWrongArgumentType(bindingArg, "binding", this));
                 }
                 binding = (RubyBinding) bindingArg;
                 self = RubyArguments.getSelf(binding.getFrame());
diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java
@@ -481,7 +481,7 @@ protected Object[] generateAccessors(Frame callerFrame, RubyModule module, Objec
         @TruffleBoundary
         private Object[] createAccessors(RubyModule module, Object[] names, Accessor accessor,
                 Visibility visibility) {
-            final Node currentNode = getNode();
+            final Node currentNode = getNode(this);
             final SourceSection sourceSection;
             if (currentNode != null) {
                 sourceSection = currentNode.getEncapsulatingSourceSection();
@@ -732,7 +732,7 @@ protected static Object evalWithString(
 
             if (count == 0) {
                 wrongNumberOfArgumentsProfile.enter(node);
-                throw new RaiseException(getContext(node), coreExceptions(node).argumentError(0, 1, 2, getNode(node)));
+                throw new RaiseException(getContext(node), coreExceptions(node).argumentError(0, 1, 2, node));
             }
 
             sourceCode = toStrNode.execute(node, RubyArguments.getArgument(rubyArgs, 0));
diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java
@@ -1410,8 +1410,7 @@ protected static RubyString forceEncodingString(RubyString string, Object newEnc
                 errorProfile.enter(node);
                 throw new RaiseException(
                         getContext(node),
-                        coreExceptions(node).argumentError(Utils.concat("unknown encoding name - ", stringName),
-                                getNode(node)));
+                        coreExceptions(node).argumentError(Utils.concat("unknown encoding name - ", stringName), node));
             }
 
             return forceEncodingNode.execute(string, rubyEncoding);
diff --git a/src/main/java/org/truffleruby/language/CallStackManager.java b/src/main/java/org/truffleruby/language/CallStackManager.java
@@ -227,7 +227,8 @@ public Backtrace getBacktrace(Node currentNode, int omit, Throwable javaThrowabl
             }
         }
 
-        return new Backtrace(currentNode, omit, javaThrowable);
+        var adoptableNode = RubyNode.getNode(currentNode);
+        return new Backtrace(adoptableNode, omit, javaThrowable);
     }
 
     @SuppressFBWarnings("ES")
diff --git a/src/main/java/org/truffleruby/language/RubyBaseNode.java b/src/main/java/org/truffleruby/language/RubyBaseNode.java
@@ -117,11 +117,7 @@ protected void reportLongLoopCount(long count) {
         LoopNode.reportLoopCount(this, count > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) count);
         // Checkstyle: resume
     }
-
-    protected Node getNode() {
-        return getNode(this);
-    }
-
+    
     protected static Node getNode(Node node) {
         boolean adoptable = node != null && node.isAdoptable();
         CompilerAsserts.partialEvaluationConstant(adoptable);
diff --git a/src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java b/src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java
@@ -128,7 +128,13 @@ protected static Object alwaysInlined(
     private static Object alwaysInlinedException(Node node, RaiseException e, AlwaysInlinedMethodNode alwaysInlinedNode,
             RootCallTarget cachedCallTarget) {
         final Node location = e.getLocation();
-        if (location != null && location.getRootNode() == alwaysInlinedNode.getRootNode()) {
+        final Node adoptedInlinedNode = getAdoptedNode(alwaysInlinedNode);
+        final var isErrorFromInlineNode = location != null && adoptedInlinedNode != null &&
+                location.getRootNode() == adoptedInlinedNode.getRootNode();
+        /* In the cached scenario the getAdoptedNode method call will have no effect. In the uncached scenario the
+         * alwaysInlinedNode is uncached, therefore no RootNode so that's why getAdoptedNode is called to determine
+         * whether the exception was thrown by the alwaysInlineNode. */
+        if (isErrorFromInlineNode) {
             // if the error originates from the inlined node, rethrow it through the CallTarget to get a proper backtrace
             return RubyContext.indirectCallWithCallNode(node, cachedCallTarget, e);
         } else {

Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ protected static ValueWrapper genericToWrapper(Node node, Object value,`
`183`	`183`	`} catch (UnsupportedMessageException e) {`
`184`	`184`	`unsupportedProfile.enter(node);`
`185`	`185`	`throw new RaiseException(getContext(node),`
`186`		`- coreExceptions(node).argumentError(e.getMessage(), getNode(node), e));`
	`186`	`+ coreExceptions(node).argumentError(e.getMessage(), node, e));`
`187`	`187`	`}`
`188`	`188`	`return nativeToWrapperNode.execute(node, handle);`
`189`	`189`	`}`
`@@ -281,7 +281,7 @@ protected static Object unwrapGeneric(Node node, Object value,`
`281`	`281`	`} catch (UnsupportedMessageException e) {`
`282`	`282`	`unsupportedProfile.enter(node);`
`283`	`283`	`throw new RaiseException(getContext(node),`
`284`		`- coreExceptions(node).argumentError(e.getMessage(), getNode(node), e));`
	`284`	`+ coreExceptions(node).argumentError(e.getMessage(), node, e));`
`285`	`285`	`}`
`286`	`286`	`return unwrapNativeNode.execute(node, handle);`
`287`	`287`	`}`
Original file line number	Diff line number	Diff line change
`@@ -336,7 +336,7 @@ protected long allocateHandle(ValueWrapper wrapper, RubyContext context, RubyLan`
`336`	`336`	`}`
`337`	`337`
`338`	`338`	`if (context.getOptions().BACKTRACE_ON_TO_NATIVE) {`
`339`		`- context.getDefaultBacktraceFormatter().printBacktraceOnEnvStderr("ValueWrapper#toNative: ", getNode());`
	`339`	`+ context.getDefaultBacktraceFormatter().printBacktraceOnEnvStderr("ValueWrapper#toNative: ", this);`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`if (block == null \|\| block.isFull()) {`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ protected static String nameToJavaString(Object object,`
`84`	`84`	`if (e.getException().getLogicalClass() == coreLibrary(node).noMethodErrorClass) {`
`85`	`85`	`throw new RaiseException(getContext(node), coreExceptions(node).typeError(`
`86`	`86`	`Utils.concat(object, " is not a symbol nor a string"),`
`87`		`- getNode(node)));`
	`87`	`+ node));`
`88`	`88`	`} else {`
`89`	`89`	`throw e;`
`90`	`90`	`}`
`@@ -99,7 +99,7 @@ protected static String nameToJavaString(Object object,`
`99`	`99`	`"String",`
`100`	`100`	`"to_str",`
`101`	`101`	`coerced,`
`102`		`- getNode(node)));`
	`102`	`+ node));`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ protected static RubySymbol toStr(Object object,`
`90`	`90`	`"String",`
`91`	`91`	`"to_str",`
`92`	`92`	`coerced,`
`93`		`- getNode(node)));`
	`93`	`+ node));`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
Original file line number	Diff line number	Diff line change
`@@ -1410,8 +1410,7 @@ protected static RubyString forceEncodingString(RubyString string, Object newEnc`
`1410`	`1410`	`errorProfile.enter(node);`
`1411`	`1411`	`throw new RaiseException(`
`1412`	`1412`	`getContext(node),`
`1413`		`- coreExceptions(node).argumentError(Utils.concat("unknown encoding name - ", stringName),`
`1414`		`- getNode(node)));`
	`1413`	`+ coreExceptions(node).argumentError(Utils.concat("unknown encoding name - ", stringName), node));`
`1415`	`1414`	`}`
`1416`	`1415`
`1417`	`1416`	`return forceEncodingNode.execute(string, rubyEncoding);`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,8 @@ public Backtrace getBacktrace(Node currentNode, int omit, Throwable javaThrowabl`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
`230`		`- return new Backtrace(currentNode, omit, javaThrowable);`
	`230`	`+ var adoptableNode = RubyNode.getNode(currentNode);`
	`231`	`+ return new Backtrace(adoptableNode, omit, javaThrowable);`
`231`	`232`	`}`
`232`	`233`
`233`	`234`	`@SuppressFBWarnings("ES")`