[GR-19220] Add Thread.each_caller_location

PullRequest: truffleruby/3922

Author: andrykonchin

CHANGELOG.md

@@ -32,6 +32,7 @@ Compatibility:
 * Add `rb_hash_new_capa` function (#3039, @itarato).
 * Fix `Encoding::Converter#primitive_convert` and raise `FrozenError` when a destination buffer argument is frozen (@andrykonchin).
 * Add `Module#undefined_instance_methods` (#3039, @itarato).
+* Add `Thread.each_caller_location` (#3039, @itarato).
 
 Performance:
 

doc/user/compatibility.md

@@ -145,6 +145,15 @@ When TruffleRuby is run as part of a polyglot application, any signals that are
 
 TruffleRuby provides similar `GC.stat` statistics to MRI, but not all statistics are available, and some statistics may be approximations. Use `GC.stat.keys` to see which are provided with real or approximate values. Missing values will return `0`.
 
+### Caller locations
+
+Using `Kernel#caller_locations` or `Thread.each_caller_location` might contain engine specific location objects and/or
+paths. This is expected and should be filtered in application code where necessary.
+
+The enumerator returned by `Thread.to_enum(:each_caller_location)` is not supporting iteration with `.next`. In CRuby
+this raises a `StopIteration`, while in TruffleRuby it iterates on an undetermined (related to where and how `.next` is
+called) call stack. It is not recommended to use this in any circumstance (neither CRuby nor TruffleRuby).
+
 ## Features with Very Low Performance
 
 ### `ObjectSpace`

spec/truffleruby.next-specs

@@ -35,3 +35,5 @@ spec/ruby/core/module/undefined_instance_methods_spec.rb
 spec/ruby/core/refinement/refined_class_spec.rb
 spec/ruby/core/module/used_refinements_spec.rb
 spec/ruby/optional/capi/hash_spec.rb
+
+spec/ruby/core/thread/each_caller_location_spec.rb

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

@@ -38,9 +38,7 @@ private static SourceSection getAvailableSourceSection(RubyContext context,
         final Backtrace backtrace = threadBacktraceLocation.backtrace;
         final int activationIndex = threadBacktraceLocation.activationIndex;
 
-        return context
-                .getUserBacktraceFormatter()
-                .nextAvailableSourceSection(backtrace.getStackTrace(), activationIndex);
+        return BacktraceFormatter.nextAvailableSourceSection(backtrace.getStackTrace(), activationIndex);
     }
 
     @CoreMethod(names = "absolute_path")

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

@@ -44,10 +44,12 @@
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.TruffleContext;
 import com.oracle.truffle.api.TruffleSafepoint;
 import com.oracle.truffle.api.TruffleSafepoint.Interrupter;
 import com.oracle.truffle.api.dsl.Bind;
+import com.oracle.truffle.api.TruffleStackTraceElement;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 import com.oracle.truffle.api.profiles.InlinedConditionProfile;
@@ -95,6 +97,7 @@
 import org.truffleruby.language.arguments.ArgumentsDescriptor;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.Backtrace;
+import org.truffleruby.language.backtrace.BacktraceFormatter;
 import org.truffleruby.language.control.KillException;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.objects.AllocationTracing;
@@ -1040,4 +1043,53 @@ protected Object runBlockingSystemCall(Object executable, RubyArray argsArray,
             return foreignToRubyNode.execute(this, result);
         }
     }
+
+    @CoreMethod(names = "each_caller_location", needsBlock = true, onSingleton = true)
+    public abstract static class EachCallerLocationNode extends CoreMethodArrayArgumentsNode {
+
+        // Skip the block of `Thread#each_caller_location` + its internal iteration.
+        private static final int SKIP = 2;
+
+        @Child private CallBlockNode yieldNode = CallBlockNode.create();
+
+        @Specialization
+        protected Object eachCallerLocation(VirtualFrame frame, RubyProc block) {
+            final List<TruffleStackTraceElement> elements = new ArrayList<>();
+
+            getContext().getCallStack().iterateFrameBindings(SKIP, frameInstance -> {
+                final Node location = frameInstance.getCallNode();
+
+                final var rootCallTarget = (RootCallTarget) frameInstance.getCallTarget();
+                final var element = TruffleStackTraceElement.create(location, rootCallTarget, null);
+                elements.add(element);
+
+                final var elementsArray = elements.toArray(Backtrace.EMPTY_STACK_TRACE_ELEMENTS_ARRAY);
+                final boolean readyToYield = BacktraceFormatter.nextAvailableSourceSection(elementsArray,
+                        0) != null;
+
+                if (readyToYield) {
+                    for (int i = 0; i < elementsArray.length; i++) {
+                        final var backtrace = new Backtrace(location, 0, elementsArray);
+                        final var rubyBacktraceLocation = new RubyBacktraceLocation(
+                                getContext().getCoreLibrary().threadBacktraceLocationClass,
+                                getLanguage().threadBacktraceLocationShape,
+                                backtrace,
+                                i);
+
+                        yieldNode.yield(block, rubyBacktraceLocation);
+                    }
+                    elements.clear();
+                }
+
+                return null;
+            });
+
+            return nil;
+        }
+
+        @Specialization
+        protected Object eachCallerLocation(VirtualFrame frame, Nil block) {
+            throw new RaiseException(getContext(), coreExceptions().localJumpError("no block given", this));
+        }
+    }
 }

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

@@ -77,6 +77,8 @@ public final class Backtrace {
     private TruffleStackTraceElement[] stackTrace;
     private int totalUnderlyingElements;
 
+    public static final TruffleStackTraceElement[] EMPTY_STACK_TRACE_ELEMENTS_ARRAY = new TruffleStackTraceElement[0];
+
     // endregion
     // region Constructors
 
@@ -87,6 +89,14 @@ public Backtrace(Node location, int omitted, Throwable javaThrowable) {
         this.javaThrowable = javaThrowable;
     }
 
+    /** For manually crafted backtraces. */
+    public Backtrace(Node location, int omitted, TruffleStackTraceElement[] stackTraceElements) {
+        this.location = location;
+        this.omitted = omitted;
+        this.javaThrowable = null;
+        this.stackTrace = stackTraceElements;
+    }
+
     /** Creates a backtrace for the given foreign exception, setting the {@link #getLocation() location} accordingly,
      * and computing the activations eagerly (since the exception itself is not retained). */
     public Backtrace(AbstractTruffleException exception) {
@@ -241,8 +251,6 @@ public TruffleStackTraceElement[] getStackTrace() {
         return getStackTrace(this.raiseException);
     }
 
-    private static final TruffleStackTraceElement[] EMPTY_STACK_TRACE_ELEMENTS_ARRAY = new TruffleStackTraceElement[0];
-
     /** Returns a ruby array of {@code Thread::Backtrace::Locations} with maximum length {@code length}, and omitting
      * locations as requested ({@link #getOmitted()}). If more locations are omitted than are available, return a Ruby
      * {@code nil}.

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

@@ -337,7 +337,7 @@ private String formatException(RubyException exception) {
 
     /** This logic should be kept in sync with
      * {@link org.truffleruby.debug.TruffleDebugNodes.IterateFrameBindingsNode} */
-    public SourceSection nextAvailableSourceSection(TruffleStackTraceElement[] stackTrace, int n) {
+    public static SourceSection nextAvailableSourceSection(TruffleStackTraceElement[] stackTrace, int n) {
         while (n < stackTrace.length) {
             final Node callNode = stackTrace[n].getLocation();