Introduce debugMode in RunnerOrchestration

debugMode allows to connect to runner processes with JDI

Author: adpi2

compiler/test/dotty/tools/debug/DebugTests.scala

@@ -24,6 +24,7 @@ object DebugTests extends ParallelTesting:
   def testFilter = Properties.testsFilter
   def updateCheckFiles: Boolean = Properties.testsUpdateCheckfile
   def failedTests = TestReporter.lastRunFailedTests
+  override def debugMode = true
 
   implicit val summaryReport: SummaryReporting = new SummaryReport
 
@@ -40,7 +41,7 @@ object DebugTests extends ParallelTesting:
 
     private def verifyDebug(dir: JFile, testSource: TestSource, warnings: Int, reporters: Seq[TestReporter], logger: LoggedRunnable) =
       if Properties.testsNoRun then addNoRunWarning()
-      else runMain(testSource.runClassPath, testSource.allToolArgs) match
+      else runMain(testSource.runClassPath) match
         case Success(output) => ()
         case Failure(output) =>
           if output == "" then

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -929,7 +929,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
     private def verifyOutput(checkFile: Option[JFile], dir: JFile, testSource: TestSource, warnings: Int, reporters: Seq[TestReporter], logger: LoggedRunnable) = {
       if Properties.testsNoRun then addNoRunWarning()
-      else runMain(testSource.runClassPath, testSource.allToolArgs) match {
+      else runMain(testSource.runClassPath) match {
         case Success(output) => checkFile match {
           case Some(file) if file.exists => diffTest(testSource, file, output.linesIterator.toList, reporters, logger)
           case _ =>

compiler/test/dotty/tools/vulpix/RunnerOrchestration.scala

@@ -2,19 +2,23 @@ package dotty
 package tools
 package vulpix
 
-import scala.language.unsafeNulls
-
-import java.io.{ File => JFile, InputStreamReader, BufferedReader, PrintStream }
-import java.nio.file.Paths
+import java.io.BufferedReader
+import java.io.File as JFile
+import java.io.IOException
+import java.io.InputStreamReader
+import java.io.PrintStream
 import java.nio.charset.StandardCharsets
-import java.util.concurrent.atomic.AtomicBoolean
+import java.nio.file.Paths
 import java.util.concurrent.TimeoutException
-
-import scala.concurrent.duration.Duration
-import scala.concurrent.{ Await, Future }
-import scala.concurrent.ExecutionContext.Implicits.global
+import java.util.concurrent.atomic.AtomicBoolean
 import scala.collection.mutable
 import scala.compiletime.uninitialized
+import scala.concurrent.Await
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+import scala.concurrent.duration.Duration
+import scala.jdk.CollectionConverters.*
+import scala.language.unsafeNulls
 
 /** Vulpix spawns JVM subprocesses (`numberOfSlaves`) in order to run tests
  *  without compromising the main JVM
@@ -48,8 +52,11 @@ trait RunnerOrchestration {
   /** Destroy and respawn process after each test */
   def safeMode: Boolean
 
+  /** Open JDI connection for testing the debugger */
+  def debugMode: Boolean = false
+
   /** Running a `Test` class's main method from the specified `dir` */
-  def runMain(classPath: String, toolArgs: ToolArgs)(implicit summaryReport: SummaryReporting): Status =
+  def runMain(classPath: String)(implicit summaryReport: SummaryReporting): Status =
     monitor.runMain(classPath)
 
   /** Kill all processes */
@@ -70,7 +77,7 @@ trait RunnerOrchestration {
     def runMain(classPath: String)(implicit summaryReport: SummaryReporting): Status =
       withRunner(_.runMain(classPath))
 
-    private class Runner(private var process: Process) {
+    private class Runner(private var process: RunnerProcess) {
       private var childStdout: BufferedReader = uninitialized
       private var childStdin: PrintStream = uninitialized
 
@@ -114,7 +121,7 @@ trait RunnerOrchestration {
         }
 
         if (childStdin eq null)
-          childStdin = new PrintStream(process.getOutputStream, /* autoFlush = */ true)
+          childStdin = new PrintStream(process.getOutputStream(), /* autoFlush = */ true)
 
         // pass file to running process
         childStdin.println(classPath)
@@ -124,7 +131,7 @@ trait RunnerOrchestration {
           val sb = new StringBuilder
 
           if (childStdout eq null)
-            childStdout = new BufferedReader(new InputStreamReader(process.getInputStream, StandardCharsets.UTF_8))
+            childStdout = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))
 
           var childOutput: String = childStdout.readLine()
 
@@ -138,7 +145,7 @@ trait RunnerOrchestration {
             childOutput = childStdout.readLine()
           }
 
-          if (process.isAlive && childOutput != null) Success(sb.toString)
+          if (process.isAlive() && childOutput != null) Success(sb.toString)
           else Failure(sb.toString)
         }
 
@@ -159,18 +166,33 @@ trait RunnerOrchestration {
       }
     }
 
+    // A Java process and its JDI port for debugging, if debugMode is enabled.
+    private class RunnerProcess(p: Process, val port: Option[Int]):
+      export p.*
+
     /** Create a process which has the classpath of the `ChildJVMMain` and the
      *  scala library.
      */
-    private def createProcess: Process = {
+    private def createProcess: RunnerProcess = {
       val url = classOf[ChildJVMMain].getProtectionDomain.getCodeSource.getLocation
       val cp = Paths.get(url.toURI).toString + JFile.pathSeparator + Properties.scalaLibrary
       val javaBin = Paths.get(sys.props("java.home"), "bin", "java").toString
-      new ProcessBuilder(javaBin, "-Dfile.encoding=UTF-8", "-Duser.language=en", "-Duser.country=US", "-Xmx1g", "-cp", cp, "dotty.tools.vulpix.ChildJVMMain")
+      val args = Seq("-Dfile.encoding=UTF-8", "-Duser.language=en", "-Duser.country=US", "-Xmx1g", "-cp", cp) ++
+        (if debugMode then Seq("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,quiet=n") else Seq.empty)
+      val command = (javaBin +: args) :+ "dotty.tools.vulpix.ChildJVMMain"
+      val process = new ProcessBuilder(command*)
         .redirectErrorStream(true)
         .redirectInput(ProcessBuilder.Redirect.PIPE)
         .redirectOutput(ProcessBuilder.Redirect.PIPE)
         .start()
+
+      val jdiPort = Option.when(debugMode):
+        val reader = new BufferedReader(new InputStreamReader(process.getInputStream, StandardCharsets.UTF_8))
+        reader.readLine() match
+          case s"Listening for transport dt_socket at address: $port" => port.toInt
+          case line => throw new IOException(s"Failed getting JDI port of child JVM: got $line")
+
+      RunnerProcess(process, jdiPort)
     }
 
     private val freeRunners = mutable.Queue.empty[Runner]