[GR-26176] Migrate from JLine 2 to JLine 3

* Readline#refresh_line is no longer implemented since the functionality
  is no longer exposed by JLine3.

Author: eregon

CHANGELOG.md

@@ -37,6 +37,10 @@ Performance:
 
 * Calls with a literal block are no longer always split but instead the decision is made by the Truffle splitting heuristic.
 
+Changes:
+
+* Migrated from JLine 2 to JLine 3 for the `readline` standard library.
+
 # 20.2.0
 
 New features:

lib/truffle/readline.rb

@@ -32,6 +32,7 @@ module Readline
     pre_input_hook
     pre_input_hook=
     redisplay
+    refresh_line
     set_screen_size
     special_prefixes
     special_prefixes=

mx.truffleruby/suite.py

@@ -166,7 +166,7 @@
                 "truffleruby:TRUFFLERUBY-ANNOTATIONS",
                 "truffleruby:TRUFFLERUBY-SHARED",
                 "truffle:TRUFFLE_API",
-                "truffle:JLINE",
+                "sdk:JLINE3",
                 "sulong:SULONG_API",
                 "JONI",
                 "JCODINGS",

spec/truffle/irb/arrows_spec.rb

@@ -14,9 +14,22 @@
     IO.popen([*ruby_exe, "-S", "irb", "-f", "--prompt=simple", "--readline"], "r+") do |io|
       io.gets.should == "Switch to inspect mode.\n"
 
-      io.puts "\e[A" # up arrow
-      # JLine seems to add a bell character
-      [">> \n", ">> \a\n"].should include(io.gets)
+      if RUBY_ENGINE == "truffleruby"
+        io.puts "B = 42"
+        io.gets.should == ">> B = 42\n"
+        io.gets.should == "=> 42\n"
+      end
+
+      io.puts "\e[B" # down arrow
+      # JLine adds a bell character (since there is no history)
+      echo = io.gets
+      [">> \n", ">> [B\n"].should include(echo)
+
+      if echo == ">> [B\n" # "[B" (echo'd by JLine) looks like a legal expression to IRB so we need to complete it
+        io.puts "]"
+        io.gets.should == ">> ]\n"
+        io.gets.should == "=> [42]\n"
+      end
 
       io.puts "22 + 33"
       # The extra bell character causes a continuation line

spec/truffle/irb/interrupt_spec.rb

@@ -23,7 +23,7 @@
       io.gets.should == ">> ^C\n"
 
       io.puts "exit"
-      io.gets.should == ">> exit\n"
+      io.gets.should == "\n"
     end
   end
 end

src/main/.checkstyle_checks.xml

@@ -202,10 +202,6 @@
       <property name="format" value='(?!=)\S\s*new\s+\w+\[0\]'/>
       <property name="message" value='Use a EMPTY_type_ARRAY constant instead.'/>
     </module>
-    <module name="RegexpSinglelineJava">
-      <property name="format" value='\bPrintWriter\b'/>
-      <property name="message" value='Use PrintStream instead, PrintWriter does not consistently flush, even when writing \n.'/>
-    </module>
     <module name="RegexpSinglelineJava">
       <property name="format" value="transferToInterpreterOnException"/>
       <property name="message" value="Don't use transferToInterpreterOnException"/>
@@ -219,7 +215,8 @@
       <property name="message" value="Type the argument as Nil instead of using a positive isNil() guard."/>
     </module>
     <module name="IllegalType">
-      <property name="illegalClassNames" value="TruffleObject,DynamicObject"/>
+      <!-- Use PrintStream instead of PrintWriter, PrintWriter does not consistently flush, even when writing \n.-->
+      <property name="illegalClassNames" value="TruffleObject,DynamicObject,PrintWriter"/>
     </module>
   </module>
   <module name="RegexpMultiline">

src/main/java/org/truffleruby/RubyContext.java

@@ -13,6 +13,7 @@
 import java.nio.ByteBuffer;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
+import java.util.Objects;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.logging.Level;
 
@@ -466,6 +467,10 @@ private void dispose() {
             return;
         }
 
+        if (consoleHolder != null) {
+            consoleHolder.close();
+        }
+
         threadManager.cleanupMainThread();
         safepointManager.checkNoRunningThreads();
 
@@ -684,6 +689,8 @@ public ConsoleHolder getConsoleHolder() {
 
     public void setConsoleHolder(ConsoleHolder consoleHolder) {
         synchronized (this) {
+            final ConsoleHolder previous = Objects.requireNonNull(this.consoleHolder);
+            previous.close();
             this.consoleHolder = consoleHolder;
         }
     }

src/main/java/org/truffleruby/core/adapters/InputStreamAdapter.java

@@ -9,17 +9,20 @@
  */
 package org.truffleruby.core.adapters;
 
-import java.io.InputStream;
-
+import org.graalvm.shadowed.org.jline.utils.NonBlockingInputStream;
 import org.truffleruby.RubyContext;
 import org.truffleruby.core.support.RubyIO;
 import org.truffleruby.language.Nil;
 
-public class InputStreamAdapter extends InputStream {
+/** extends NonBlockingInputStream so JLine does not create an extra thread and calls read() on the same thread as
+ * calling readLine(). */
+public class InputStreamAdapter extends NonBlockingInputStream {
 
     private final RubyContext context;
     private final RubyIO object;
 
+    private int peeked = EOF;
+
     public InputStreamAdapter(RubyContext context, RubyIO object) {
         this.context = context;
         this.object = object;
@@ -30,9 +33,24 @@ public int read() {
         final Object result = context.send(object, "getbyte");
 
         if (result == Nil.INSTANCE) {
-            return -1;
+            return EOF;
         }
 
         return (int) result;
     }
+
+    @Override
+    public int read(long timeout, boolean isPeek) {
+        if (peeked != EOF) {
+            int c = peeked;
+            this.peeked = EOF;
+            return c;
+        }
+
+        int character = read();
+        if (isPeek) {
+            peeked = character;
+        }
+        return character;
+    }
 }

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

@@ -500,29 +500,6 @@ public <T> T runUntilResult(Node currentNode, BlockingAction<T> action) {
         return result;
     }
 
-    /** Runs {@code action} until it returns a non-null value. The blocking action might be {@link Thread#interrupted()}
-     * , for instance by the {@link SafepointManager}, in which case it will be run again. The unblocking action is
-     * registered with the thread manager and will be invoked if the {@link SafepointManager} needs to interrupt the
-     * thread. If the blocking action is making a native call, simply interrupting the thread will not unblock the
-     * action. It is the responsibility of the unblocking action to break out of the native call so the thread can be
-     * interrupted.
-     *
-     * @param blockingAction must not touch any Ruby state
-     * @param unblockingAction must not touch any Ruby state
-     * @return the first non-null return value from {@code action} */
-    @TruffleBoundary
-    public <T> T runUntilResult(Node currentNode, BlockingAction<T> blockingAction, UnblockingAction unblockingAction) {
-        assert unblockingAction != null;
-        final UnblockingActionHolder holder = getActionHolder(Thread.currentThread());
-
-        final UnblockingAction oldUnblockingAction = holder.changeTo(unblockingAction);
-        try {
-            return runUntilResult(currentNode, blockingAction);
-        } finally {
-            holder.restore(oldUnblockingAction);
-        }
-    }
-
     @TruffleBoundary
     UnblockingActionHolder getActionHolder(Thread thread) {
         return ConcurrentOperations.getOrCompute(unblockingActions, thread, t -> new UnblockingActionHolder(t, null));