.

Author: lihaoyi

repl/src/dotty/tools/repl/JLineTerminal.scala

@@ -15,14 +15,16 @@ import org.jline.reader.*
 import org.jline.reader.impl.LineReaderImpl
 import org.jline.reader.impl.history.DefaultHistory
 import org.jline.terminal.TerminalBuilder
+import org.jline.terminal.Attributes
+import org.jline.terminal.Attributes.ControlChar
 import org.jline.utils.AttributedString
 
 class JLineTerminal extends java.io.Closeable {
   // import java.util.logging.{Logger, Level}
   // Logger.getLogger("org.jline").setLevel(Level.FINEST)
 
   private val terminal =
-    var builder = TerminalBuilder.builder()
+    val builder = TerminalBuilder.builder()
     if System.getenv("TERM") == "dumb" then
       // Force dumb terminal if `TERM` is `"dumb"`.
       // Note: the default value for the `dumb` option is `null`, which allows
@@ -31,6 +33,16 @@ class JLineTerminal extends java.io.Closeable {
       // This option is used at https://github.com/jline/jline3/blob/894b5e72cde28a551079402add4caea7f5527806/terminal/src/main/java/org/jline/terminal/TerminalBuilder.java#L528.
       builder.dumb(true)
     builder.build()
+  
+  // Save original attributes before any modifications
+  private val originalAttributes = terminal.getAttributes
+
+  // Disable VINTR so Ctrl-C is not converted to SIGINT by the tty driver, then enter raw mode
+  val noIntr = new Attributes(originalAttributes)
+  noIntr.setControlChar(ControlChar.VINTR, 0)
+  terminal.setAttributes(noIntr)
+  terminal.enterRawMode()
+
   private val history = new DefaultHistory
 
   private def magenta(str: String)(using Context) =
@@ -78,14 +90,43 @@ class JLineTerminal extends java.io.Closeable {
       .option(DISABLE_EVENT_EXPANSION, true)    // don't process escape sequences in input
       .build()
 
+    lineReader.getKeyMaps.get(LineReader.MAIN).bind(
+      new Widget { override def apply(): Boolean = throw new UserInterruptException("") },
+      "\u0003"
+    )
     lineReader.readLine(prompt)
   }
 
-  def close(): Unit = terminal.close()
+  def close(): Unit =
+    try terminal.setAttributes(originalAttributes)
+    finally terminal.close()
+
+  /** Execute a block while monitoring for Ctrl-C keypresses.
+   *  Calls the handler when Ctrl-C is detected during block execution.
+   */
+  def withMonitoringCtrlC[T](handler: () => Unit)(block: => T): T = {
+    @volatile var monitoring = true
+    val terminalReader = terminal.reader()
+
+    val monitorThread = new Thread(() => {
+      while (monitoring) {
+        val ch =
+          try terminalReader.peek(1) // timeout after 1ms so the loop gets a chance to check `monitoring`
+          catch { case _: Exception => -1 } // Ignore all read errors, just continue
 
-  /** Register a signal handler and return the previous handler */
-  def handle(signal: org.jline.terminal.Terminal.Signal, handler: org.jline.terminal.Terminal.SignalHandler): org.jline.terminal.Terminal.SignalHandler =
-    terminal.handle(signal, handler)
+        if (ch == 3 /* Ctrl-C is ASCII 0x03 */ && monitoring) handler() 
+      }
+    }, "REPL-CtrlC-Monitor")
+    monitorThread.setDaemon(true)
+    monitorThread.start()
+
+    try block
+    finally {
+      monitoring = false
+      Thread.interrupted() // clear any interrupted flag so the `join` below doesn't explode
+      monitorThread.join()
+    }
+  }
 
   /** Provide syntax highlighting */
   private class Highlighter(using Context) extends reader.Highlighter {

repl/src/dotty/tools/repl/ReplDriver.scala

@@ -214,48 +214,40 @@ class ReplDriver(settings: Array[String],
         val line = terminal.readLine(completer)
         ParseResult(line)
       } catch {
-        case _: EndOfFileException => // Ctrl+D
-          Quit
-        case _: UserInterruptException => // Ctrl+C at prompt - clear and continue
-          SigKill
+        case _: EndOfFileException => Quit // Ctrl+D
+        case _: UserInterruptException => SigKill // Ctrl+C at prompt
       }
     }
 
     @tailrec def loop(using state: State)(): State = {
 
       val res = readLine()
       if (res == Quit) state
-      // Ctrl-C pressed at prompt - just continue with same state (line is cleared by JLine)
       else if (res == SigKill) loop(using state)()
       else {
-        // Set up interrupt handler for command execution
+        // Set up Ctrl-C monitoring for command execution
         var firstCtrlCEntered = false
         val thread = Thread.currentThread()
 
         // Clear the stop flag before executing new code
         ReplBytecodeInstrumentation.setStopFlag(rendering.classLoader()(using state.context), false)
 
-        val previousSignalHandler = terminal.handle(
-          org.jline.terminal.Terminal.Signal.INT,
-          (sig: org.jline.terminal.Terminal.Signal) => {
+        val newState = terminal.withMonitoringCtrlC(
+          handler = () =>
             if (!firstCtrlCEntered) {
               firstCtrlCEntered = true
               // Set the stop flag to trigger throwIfReplStopped() in instrumented code
               ReplBytecodeInstrumentation.setStopFlag(rendering.classLoader()(using state.context), true)
-              // Also interrupt the thread as a fallback for non-instrumented code
+              // Also interrupt the thread as a fallback for non-instrumented code, e.g. IO/sleeps
               thread.interrupt()
-              out.println("\nAttempting to interrupt running thread with `Thread.interrupt`")
+              out.println("\nAttempting to interrupt running REPL command")
             } else {
               out.println("\nTerminating REPL Process...")
               System.exit(130)  // Standard exit code for SIGINT
             }
-          }
-        )
-
-        val newState =
-          try interpret(res)
-          // Restore previous handler
-          finally terminal.handle(org.jline.terminal.Terminal.Signal.INT, previousSignalHandler)
+        ) {
+          interpret(res)
+        }
 
         loop(using newState)()
       }