Use InterruptibleFunction for runUntilResultKeepStatus()

Author: eregon

src/main/java/org/truffleruby/core/fiber/FiberManager.java

@@ -82,7 +82,10 @@ public static void waitForInitializationEntered(RubyContext context, RubyFiber f
         assert context.getEnv().getContext().isEntered();
         final CountDownLatch initializedLatch = fiber.initializedLatch;
 
-        context.getThreadManager().runUntilResultKeepStatus(currentNode, CountDownLatch::await, initializedLatch);
+        context.getThreadManager().runUntilResultKeepStatus(currentNode, latch -> {
+            latch.await();
+            return BlockingAction.SUCCESS;
+        }, initializedLatch);
 
         final Throwable uncaughtException = fiber.uncaughtException;
         if (uncaughtException != null) {

src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java

@@ -1088,19 +1088,13 @@ protected Object match(
         @TruffleBoundary
         private int runMatch(Matcher matcher, int startPos, int range, boolean onlyMatchAtStart) {
             // Keep status as RUN because MRI has an uninterruptible Regexp engine
-            int[] result = new int[1];
             if (onlyMatchAtStart) {
-                getContext().getThreadManager().runUntilResultKeepStatus(
-                        this,
-                        r -> r[0] = matcher.matchInterruptible(startPos, range, Option.DEFAULT),
-                        result);
+                return getContext().getThreadManager().runUntilResultKeepStatus(this,
+                        unused -> matcher.matchInterruptible(startPos, range, Option.DEFAULT), null);
             } else {
-                getContext().getThreadManager().runUntilResultKeepStatus(
-                        this,
-                        r -> r[0] = matcher.searchInterruptible(startPos, range, Option.DEFAULT),
-                        result);
+                return getContext().getThreadManager().runUntilResultKeepStatus(this,
+                        unused -> matcher.searchInterruptible(startPos, range, Option.DEFAULT), null);
             }
-            return result[0];
         }
 
         private boolean assertValidRegion(Region region) {

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

@@ -26,6 +26,7 @@
 import com.oracle.truffle.api.TruffleOptions;
 import com.oracle.truffle.api.TruffleSafepoint;
 import com.oracle.truffle.api.TruffleSafepoint.Interrupter;
+import com.oracle.truffle.api.TruffleSafepoint.InterruptibleFunction;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.object.DynamicObjectLibrary;
 import com.oracle.truffle.api.source.SourceSection;
@@ -504,9 +505,9 @@ public interface BlockingAction<T> {
     }
 
     @TruffleBoundary
-    public <T> void runUntilResultKeepStatus(Node currentNode, TruffleSafepoint.Interruptible<T> action, T object) {
+    public <T, R> R runUntilResultKeepStatus(Node currentNode, InterruptibleFunction<T, R> action, T object) {
         assert context.getEnv().getContext().isEntered() : "Use retryWhileInterrupted() when not entered";
-        TruffleSafepoint.setBlockedThreadInterruptible(currentNode, action, object);
+        return TruffleSafepoint.setBlockedThreadInterruptibleFunction(currentNode, action, object);
     }
 
     public static Object executeBlockingCall(RubyThread thread, Interrupter interrupter, Object executable,
@@ -646,7 +647,10 @@ public void killAndWaitOtherThreads() {
         // Wait and join all Java threads we created
         for (Thread thread : rubyManagedThreads) {
             if (thread != Thread.currentThread()) {
-                runUntilResultKeepStatus(DummyNode.INSTANCE, Thread::join, thread);
+                runUntilResultKeepStatus(DummyNode.INSTANCE, t -> {
+                    t.join();
+                    return BlockingAction.SUCCESS;
+                }, thread);
             }
         }
     }