simplify Backtrace#getBacktraceLocations usage

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);
+                    backtraceLocations = backtrace.getBacktraceLocations(GetBacktraceException.UNLIMITED, this);
                     Layouts.EXCEPTION.setBacktraceLocations(exception, backtraceLocations);
                 }
                 return backtraceLocations;

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

@@ -324,10 +324,7 @@ private DynamicObject innerCallerLocations(int omit, int length) {
                     ? GetBacktraceException.UNLIMITED
                     : omitted + length;
 
-            // Fill in the stack trace.
-            backtrace.getActivations(new GetBacktraceException(this, limit));
-
-            return backtrace.getBacktraceLocations(length);
+            return backtrace.getBacktraceLocations(length, this);
         }
     }
 

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

@@ -153,7 +153,7 @@ protected DynamicObject backtraceLocations(
 
         @TruffleBoundary
         private DynamicObject backtraceLocationsInternal(DynamicObject rubyThread, int omit, int length) {
-            final Memo<Backtrace> backtraceMemo = new Memo<>(null);
+            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
@@ -162,21 +162,17 @@ private DynamicObject backtraceLocationsInternal(DynamicObject rubyThread, int o
 
             final SafepointAction safepointAction = (thread1, currentNode) -> {
                 final Backtrace backtrace = getContext().getCallStack().getBacktrace(this, omit);
-                backtraceMemo.set(backtrace);
-                // Fill in the stack trace.
-                backtrace.getActivations(new GetBacktraceException(this, stackTraceElementsLimit));
+                backtraceLocationsMemo.set(backtrace.getBacktraceLocations(length, this));
             };
 
             getContext()
                     .getSafepointManager()
                     .pauseRubyThreadAndExecute(rubyThread, this, safepointAction);
 
             // If the thread is dead or aborting the SafepointAction will not run.
-            if (backtraceMemo.get() == null) {
-                return nil();
-            }
-
-            return backtraceMemo.get().getBacktraceLocations(length);
+            return backtraceLocationsMemo.get() == null
+                    ? nil()
+                    : backtraceLocationsMemo.get();
         }
     }
 

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

@@ -269,17 +269,35 @@ public Activation[] getActivations() {
      * <p>The length can be negative, in which case it is treated as a range ending. Use -1 to
      * get the maximum length.
      *
-     * <p>If the stack trace hasn't been filled yet, this method will fill it.
+     * <p>This causes the activations to be computed if not yet the case.
      *
      * @param length the maximum number of locations to return (if positive), or -1 minus the
      *               number of items to exclude at the end. You can use
      *               {@link GetBacktraceException#UNLIMITED} to signal that you want all locations.
      *
+     * @param node the node at which we're requiring the backtrace. Can be null if the backtrace
+     *             is associated with a ruby exception or if we are sure the activations have
+     *             already been computed.
+     *
      */
-    public DynamicObject getBacktraceLocations(int length) {
+    public DynamicObject getBacktraceLocations(int length, Node node) {
 
         final RubyContext context = RubyLanguage.getCurrentContext();
-        final int activationsLength = getActivations().length;
+
+        final int activationsLength;
+        if (this.raiseException != null) {
+            // 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 {
+            // 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) {