Add Thread.each_caller_location.

Author: itarato

spec/ruby/core/thread/each_caller_location_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../../spec_helper'
+
+describe "Thread.each_caller_location" do
+  ruby_version_is "3.2" do
+    it "matches caller_locations content and type" do
+      i = 0
+      ecl = Thread.each_caller_location { |x| i += 1; break x if i == 1 }
+
+      ecl.to_s.should == caller_locations(1, 1)[0].to_s
+      ecl.should be_kind_of(Thread::Backtrace::Location)
+    end
+
+    it "`break` stops the backtrace iteration" do
+      i = 0
+      ary = []
+      last = Thread.each_caller_location { |x| ary << x; i += 1; break x if i == 2 }
+
+      ary.map(&:to_s).should == caller_locations(1, 2).map(&:to_s)
+      last.should be_kind_of(Thread::Backtrace::Location)
+    end
+
+    it "show multiple block frames" do
+      i = 0
+      ary = []
+      cllr = nil
+      last = nil
+
+      ->{
+        ->{
+          cllr = caller_locations(1, 2)
+          last = Thread.each_caller_location { |x| ary << x; i += 1; break x if i == 2 }
+        }.()
+      }.()
+
+      cllr.map(&:to_s).should == ary.map(&:to_s)
+      last.should be_kind_of(Thread::Backtrace::Location)
+    end
+
+    it "works with #to_enum" do
+      cllr = caller_locations(1, 2)
+      ary = Thread.to_enum(:each_caller_location).to_a[2..3]
+
+      cllr.map(&:to_s).should == ary.map(&:to_s)
+    end
+
+    it "raises StopIteration" do
+      ecl = Thread.to_enum(:each_caller_location)
+      -> { ecl.next }.should raise_error(StopIteration)
+    end
+  end
+end

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

@@ -1034,4 +1034,22 @@ protected Object runBlockingSystemCall(Object executable, RubyArray argsArray,
             return foreignToRubyNode.executeConvert(result);
         }
     }
+
+    @Primitive(name = "thread_each_caller_location")
+    public abstract static class CallerLocationsNode extends PrimitiveArrayArgumentsNode {
+
+        @Child private CallBlockNode yieldNode = CallBlockNode.create();
+
+        @Specialization
+        protected Object eachCallerLocation(VirtualFrame frame) {
+            final RubyProc block = (RubyProc) RubyArguments.getBlock(frame);
+            final Backtrace backtrace = getContext().getCallStack().getBacktrace(this, 2);
+
+            backtrace.getBacktraceRawLocations(getContext(), getLanguage(), -1, this, (location) -> {
+                yieldNode.yield(block, location);
+            });
+
+            return nil;
+        }
+    }
 }

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

@@ -70,6 +70,11 @@ public class Backtrace {
     // region Fields
     // See accessors for info on most undocumented fields.
 
+    /** Used for providing business logic to do something with the location when walking the backtrace. */
+    public interface LocationHandler {
+        void call(RubyBacktraceLocation loc);
+    }
+
     private final Node location;
     private final int omitted;
     private RaiseException raiseException;
@@ -259,6 +264,20 @@ public TruffleStackTraceElement[] getStackTrace() {
      * @param node the node at which we're requiring the backtrace. Can be null if the backtrace is associated with a */
     @TruffleBoundary
     public Object getBacktraceLocations(RubyContext context, RubyLanguage language, int length, Node node) {
+        final Object[] locations = getBacktraceRawLocations(context, language, length, node, null);
+
+        if (locations == null) {
+            return omitted > totalUnderlyingElements
+                    ? Nil.INSTANCE
+                    : ArrayHelpers.createEmptyArray(context, language);
+        }
+
+        return ArrayHelpers.createArray(context, language, locations);
+    }
+
+    @TruffleBoundary
+    public Object[] getBacktraceRawLocations(RubyContext context, RubyLanguage language, int length,
+            Node node, LocationHandler locationHandler) {
         final int stackTraceLength;
         if (this.raiseException != null) {
             // When dealing with the backtrace of a Ruby exception, we use the wrapping
@@ -275,9 +294,7 @@ public Object getBacktraceLocations(RubyContext context, RubyLanguage language,
 
         // Omitting more locations than available should return nil.
         if (stackTraceLength == 0) {
-            return omitted > totalUnderlyingElements
-                    ? Nil.INSTANCE
-                    : ArrayHelpers.createEmptyArray(context, language);
+            return null;
         }
 
         final int locationsLength = length < 0
@@ -287,16 +304,23 @@ public Object getBacktraceLocations(RubyContext context, RubyLanguage language,
                 : Math.min(stackTraceLength, length);
 
         final Object[] locations = new Object[locationsLength];
+
         for (int i = 0; i < locationsLength; i++) {
             final RubyBacktraceLocation instance = new RubyBacktraceLocation(
                     context.getCoreLibrary().threadBacktraceLocationClass,
                     language.threadBacktraceLocationShape,
                     this,
                     i);
             AllocationTracing.trace(instance, node);
+
+            if (locationHandler != null) {
+                locationHandler.call(instance);
+            }
+
             locations[i] = instance;
         }
-        return ArrayHelpers.createArray(context, language, locations);
+
+        return locations;
     }
 
     // endregion

src/main/ruby/truffleruby/core/thread.rb

@@ -123,6 +123,12 @@ def start(...)
       thread
     end
     alias_method :fork, :start
+
+    def each_caller_location
+      raise LocalJumpError, 'no block given' unless block_given?
+
+      Primitive.thread_each_caller_location
+    end
   end
 
   # Instance methods