reformat

Author: Nicolas Laurent

src/main/java/org/truffleruby/core/exception/ExceptionNodes.java

@@ -187,7 +187,7 @@ protected Object backtraceLocations(DynamicObject exception,
                 DynamicObject backtraceLocations = Layouts.EXCEPTION.getBacktraceLocations(exception);
                 if (hasLocationsProfile.profile(backtraceLocations == null)) {
                     Backtrace backtrace = Layouts.EXCEPTION.getBacktrace(exception);
-                    backtraceLocations = backtrace.getBacktraceLocations(GetBacktraceException.UNLIMITED, this);
+                    backtraceLocations = backtrace.getBacktraceLocations(GetBacktraceException.UNLIMITED, null);
                     Layouts.EXCEPTION.setBacktraceLocations(exception, backtraceLocations);
                 }
                 return backtraceLocations;

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -318,12 +318,6 @@ private DynamicObject innerCallerLocations(int omit, int length) {
             // Always skip #caller_locations.
             final int omitted = omit + 1;
             final Backtrace backtrace = getContext().getCallStack().getBacktrace(this, omitted);
-
-            // We can't set an effective limit when dealing with negative range endings.
-            final int limit = length < 0
-                    ? GetBacktraceException.UNLIMITED
-                    : omitted + length;
-
             return backtrace.getBacktraceLocations(length, this);
         }
     }

src/main/java/org/truffleruby/core/thread/ThreadNodes.java

@@ -155,11 +155,6 @@ protected DynamicObject backtraceLocations(
         private DynamicObject backtraceLocationsInternal(DynamicObject rubyThread, int omit, int length) {
             final Memo<DynamicObject> backtraceLocationsMemo = new Memo<>(null);
 
-            // We can't set an effective limit when dealing with negative range endings.
-            final int stackTraceElementsLimit = length < 0
-                    ? GetBacktraceException.UNLIMITED
-                    : omit + length;
-
             final SafepointAction safepointAction = (thread1, currentNode) -> {
                 final Backtrace backtrace = getContext().getCallStack().getBacktrace(this, omit);
                 backtraceLocationsMemo.set(backtrace.getBacktraceLocations(length, this));

src/main/java/org/truffleruby/language/CallStackManager.java

@@ -228,9 +228,13 @@ public boolean ignoreFrame(Node callNode, RootCallTarget callTarget) {
             }
         }
 
-        return rootNode != null && rootNode.isInternal() && !BacktraceFormatter.isCore(context, rootNode.getSourceSection())
-                || rootNode instanceof InternalRootNode
-                || callNode.getEncapsulatingSourceSection() == null;
+        if (rootNode != null && rootNode.isInternal() &&
+                !BacktraceFormatter.isCore(context, rootNode.getSourceSection())) {
+            return true;
+        }
+
+        return rootNode instanceof InternalRootNode || callNode.getEncapsulatingSourceSection() == null;
+
     }
 
 }

src/main/java/org/truffleruby/language/backtrace/Backtrace.java

@@ -53,7 +53,8 @@
  * may have set a custom backtrace (an array of strings).
  *
  * <p>In general, there isn't any guarantee that the getters will return non-null values, excepted
- * {@link #getActivations(), {@link #getActivations(Throwable)} and {@link #getBacktraceLocations(int)}.
+ * {@link #getActivations()}, {@link #getActivations(Throwable)} and
+ * {@link #getBacktraceLocations(int, Node)}.
  *
  * <p>NOTE(norswap): And this is somewhat unfortunate, as it's difficult to track the assumptions
  * on the backtrace object and generally require being very defensive depending on the information
@@ -245,7 +246,7 @@ public Activation[] getActivations(Throwable truffleException) {
                 activations.add(new Activation(callNode, methodName));
             }
 
-            activationCount++;
+            ++activationCount;
         }
 
         // If there are activations with a InternalMethod but no caller information above in the
@@ -291,16 +292,15 @@ public DynamicObject getBacktraceLocations(int length, Node node) {
             // When dealing with the backtrace of a Ruby exception, we use the wrapping
             // exception and we don't set a limit on the retrieved activations.
             activationsLength = getActivations().length;
-        }
-        else {
+        } else {
             // We can't set an effective limit when dealing with negative range endings.
             final int stackTraceElementsLimit = length < 0
                     ? GetBacktraceException.UNLIMITED
                     : omitted + length;
             final Throwable e = new GetBacktraceException(node, stackTraceElementsLimit);
             activationsLength = getActivations(e).length;
         }
-        
+
         // Omitting more locations than available should return nil.
         if (activationsLength == 0) {
             return omitted > totalUnderlyingActivations
@@ -315,7 +315,7 @@ public DynamicObject getBacktraceLocations(int length, Node node) {
         final int locationsLength = length < 0
                 ? activationsLength + 1 + length
                 : Math.min(activationsLength, length);
-        
+
         final Object[] locations = new Object[locationsLength];
         final DynamicObjectFactory factory = context.getCoreLibrary().threadBacktraceLocationFactory;
         for (int i = 0; i < locationsLength; i++) {