WIP Cleanup zinc server (#6128)

Author: lihaoyi

ci/mill-bootstrap.patch

@@ -8,7 +8,7 @@ index 5c388fafb6e..31763326edf 100644
              testParallelism(),
 -            testLogLevel()
 +            testLogLevel(),
-+            jvmWorker = jvmWorker().worker()
++            jvmWorker = jvmWorker().internalWorker()
            )
            testModuleUtil.runTests()
          }

contrib/twirllib/test/src/mill/twirllib/HelloWorldTests.scala

@@ -81,7 +81,7 @@ trait HelloWorldTests extends TestSuite {
     }
     test("compileTwirl") {
       skipUnsupportedVersions {
-        UnitTester(HelloWorld, resourcePath / "hello-world", debugEnabled = true).scoped { eval =>
+        UnitTester(HelloWorld, resourcePath / "hello-world").scoped { eval =>
           val res = eval.apply(HelloWorld.core.compileTwirl)
           assert(res.isRight)
           val Right(result) = res: @unchecked

integration/ide/bsp-server/resources/snapshots/logging

@@ -3,12 +3,12 @@
 [1-buildInitialize] Entered buildInitialize
 [1-buildInitialize] Got client semanticdbVersion: * Enabling SemanticDB support.
 [1-buildInitialize] buildInitialize took * msec
-[bsp-init-mill-build/build.mill-59] [info] compiling * Scala sources to * ...
-[bsp-init-mill-build/build.mill-59] [info] done compiling
-[bsp-init-build.mill-59] [info] compiling * Scala sources to * ...
-[bsp-init-build.mill-59] [info] done compiling
-[bsp-init-106] [info] compiling * Scala source to * ...
-[bsp-init-106] [info] done compiling
+[bsp-init-mill-build/build.mill-60] [info] compiling * Scala sources to * ...
+[bsp-init-mill-build/build.mill-60] [info] done compiling
+[bsp-init-build.mill-60] [info] compiling * Scala sources to * ...
+[bsp-init-build.mill-60] [info] done compiling
+[bsp-init-107] [info] compiling * Scala source to * ...
+[bsp-init-107] [info] done compiling
 [bsp-init] BSP disabled for target file:///workspace/dependsOnSkipped because of its dependencies file:///workspace/skipped
 [bsp-init] BSP disabled for target file:///workspace/skipped via BspModuleApi#enableBsp
 [bsp-init] SNAPSHOT
@@ -37,12 +37,12 @@
 [4-compile] buildTargetCompile took * msec
 [5-compile] Entered buildTargetCompile
 [5-compile] Evaluating 1 task
-[5-compile-55] [info] compiling * Scala source to * ...
-[5-compile-55] [error] *:2:3: not found: value nope
-[5-compile-55] [error]   nope
-[5-compile-55] [error]   ^
-[5-compile-55] [error] one error found
-[5-compile-55] errored.compilation-error.semanticDbDataDetailed task failed
+[5-compile-56] [info] compiling * Scala source to * ...
+[5-compile-56] [error] *:2:3: not found: value nope
+[5-compile-56] [error]   nope
+[5-compile-56] [error]   ^
+[5-compile-56] [error] one error found
+[5-compile-56] errored.compilation-error.semanticDbDataDetailed task failed
 [5-compile] Done
 [5-compile] buildTargetCompile took * msec
 [6-compile] Entered buildTargetCompile

libs/androidlib/src/mill/androidlib/AndroidModule.scala

@@ -516,22 +516,21 @@ trait AndroidModule extends JavaModule { outer =>
    * The Java compiled classes of [[androidResources]]
    */
   def androidCompiledRClasses: T[CompilationResult] = Task(persistent = true) {
-    val jOpts = JavaCompilerOptions(javacOptions() ++ mandatoryJavacOptions())
-    jvmWorker()
-      .internalWorker()
-      .compileJava(
-        ZincCompileJava(
-          upstreamCompileOutput = upstreamCompileOutput(),
-          sources = androidLibsRClasses().map(_.path),
-          compileClasspath = Seq.empty,
-          javacOptions = jOpts.compiler,
-          incrementalCompilation = true
-        ),
-        javaHome = javaHome().map(_.path),
-        javaRuntimeOptions = jOpts.runtime,
-        reporter = Task.reporter.apply(hashCode),
-        reportCachedProblems = zincReportCachedProblems()
-      )
+    val jOpts = JavaCompilerOptions.split(javacOptions() ++ mandatoryJavacOptions())
+    val worker = jvmWorker().internalWorker()
+    worker.apply(
+      ZincCompileJava(
+        upstreamCompileOutput = upstreamCompileOutput(),
+        sources = androidLibsRClasses().map(_.path),
+        compileClasspath = Seq.empty,
+        javacOptions = jOpts.compiler,
+        incrementalCompilation = true
+      ),
+      javaHome = javaHome().map(_.path),
+      javaRuntimeOptions = jOpts.runtime,
+      reporter = Task.reporter.apply(hashCode),
+      reportCachedProblems = zincReportCachedProblems()
+    )
   }
 
   def androidLibRClasspath: T[Seq[PathRef]] = Task {
@@ -729,10 +728,10 @@ trait AndroidModule extends JavaModule { outer =>
 
     val rJar = Task.dest / "R.jar"
 
-    val jOpts = JavaCompilerOptions(javacOptions() ++ mandatoryJavacOptions())
-    val classesDest = jvmWorker()
-      .internalWorker()
-      .compileJava(
+    val jOpts = JavaCompilerOptions.split(javacOptions() ++ mandatoryJavacOptions())
+    val worker = jvmWorker().internalWorker()
+    val classesDest = worker
+      .apply(
         ZincCompileJava(
           upstreamCompileOutput = upstreamCompileOutput(),
           sources = sources.map(_.path),

libs/javalib/api/src/mill/javalib/api/JvmWorkerApi.scala

@@ -47,19 +47,4 @@ trait JvmWorkerApi {
       javaHome: Option[os.Path],
       args: Seq[String]
   )(using ctx: JvmWorkerApi.Ctx): Boolean
-
-  def discoverTests(
-      value: mill.javalib.api.internal.ZincDiscoverTests,
-      javaHome: Option[os.Path]
-  )(using ctx: JvmWorkerApi.Ctx): Seq[String] = Nil
-
-  def getTestTasks(
-      value: mill.javalib.api.internal.ZincGetTestTasks,
-      javaHome: Option[os.Path]
-  )(using ctx: JvmWorkerApi.Ctx): Seq[String] = Nil
-
-  def discoverJunit5Tests(
-      value: mill.javalib.api.internal.ZincDiscoverJunit5Tests,
-      javaHome: Option[os.Path]
-  )(using ctx: JvmWorkerApi.Ctx): Seq[String] = Nil
 }

libs/javalib/api/src/mill/javalib/api/internal/JvmWorkerApi.scala renamed to libs/javalib/api/src/mill/javalib/api/internal/InternalJvmWorkerApi.scala

@@ -5,33 +5,19 @@ import mill.api.daemon.internal.CompileProblemReporter
 import mill.javalib.api.CompilationResult
 import mill.javalib.api.JvmWorkerApi as PublicJvmWorkerApi
 import mill.javalib.api.JvmWorkerApi.Ctx
+import mill.javalib.api.internal.ZincOperation
 import os.Path
 
-trait JvmWorkerApi extends PublicJvmWorkerApi {
+trait InternalJvmWorkerApi extends PublicJvmWorkerApi {
 
   /** Compile a Java-only project. */
-  def compileJava(
-      op: ZincCompileJava,
+  def apply(
+      op: ZincOperation,
       javaHome: Option[os.Path],
-      javaRuntimeOptions: JavaRuntimeOptions,
-      reporter: Option[CompileProblemReporter],
-      reportCachedProblems: Boolean
-  )(using context: JvmWorkerApi.Ctx): Result[CompilationResult]
-
-  /** Compile a mixed Scala/Java or Scala-only project. */
-  def compileMixed(
-      op: ZincCompileMixed,
-      javaHome: Option[os.Path],
-      javaRuntimeOptions: JavaRuntimeOptions,
-      reporter: Option[CompileProblemReporter],
-      reportCachedProblems: Boolean
-  )(using context: JvmWorkerApi.Ctx): Result[CompilationResult]
-
-  /** Compiles a Scaladoc jar. */
-  def scaladocJar(
-      op: ZincScaladocJar,
-      javaHome: Option[os.Path]
-  )(using context: JvmWorkerApi.Ctx): Boolean
+      javaRuntimeOptions: Seq[String] = Nil,
+      reporter: Option[CompileProblemReporter] = None,
+      reportCachedProblems: Boolean = false
+  )(using context: InternalJvmWorkerApi.Ctx): op.Response
 
   // public API forwarder
   override def compileJava(
@@ -44,8 +30,8 @@ trait JvmWorkerApi extends PublicJvmWorkerApi {
       reportCachedProblems: Boolean,
       incrementalCompilation: Boolean
   )(using ctx: Ctx): Result[CompilationResult] = {
-    val jOpts = JavaCompilerOptions(javacOptions)
-    compileJava(
+    val jOpts = JavaCompilerOptions.split(javacOptions)
+    apply(
       ZincCompileJava(
         upstreamCompileOutput = upstreamCompileOutput,
         sources = sources,
@@ -77,8 +63,8 @@ trait JvmWorkerApi extends PublicJvmWorkerApi {
       incrementalCompilation: Boolean,
       auxiliaryClassFileExtensions: Seq[String]
   )(using ctx: Ctx): Result[CompilationResult] = {
-    val jOpts = JavaCompilerOptions(javacOptions)
-    compileMixed(
+    val jOpts = JavaCompilerOptions.split(javacOptions)
+    apply(
       ZincCompileMixed(
         upstreamCompileOutput = upstreamCompileOutput,
         sources = sources,
@@ -108,18 +94,21 @@ trait JvmWorkerApi extends PublicJvmWorkerApi {
       javaHome: Option[Path],
       args: Seq[String]
   )(using ctx: Ctx): Boolean = {
-    scaladocJar(
+    apply(
       ZincScaladocJar(
         scalaVersion = scalaVersion,
         scalaOrganization = scalaOrganization,
         compilerClasspath = compilerClasspath,
         scalacPluginClasspath = scalacPluginClasspath,
         args = args
       ),
-      javaHome = javaHome
+      javaHome = javaHome,
+      javaRuntimeOptions = Nil,
+      None,
+      false
     )
   }
 }
-object JvmWorkerApi {
+object InternalJvmWorkerApi {
   type Ctx = PublicJvmWorkerApi.Ctx
 }

libs/javalib/api/src/mill/javalib/api/internal/JavaCompilerOptions.scala

@@ -1,31 +1,10 @@
 package mill.javalib.api.internal
 
-/** Java compiler options, without the `-J` options (the Java runtime options). */
-case class JavaCompilerOptions private (options: Seq[String]) {
-  {
-    val runtimeOptions = options.filter(_.startsWith("-J"))
-    if (runtimeOptions.nonEmpty) throw new IllegalArgumentException(
-      s"Providing Java runtime options to javac is not supported."
-    )
-  }
-}
 object JavaCompilerOptions {
-  given rw: upickle.ReadWriter[JavaCompilerOptions] =
-    summon[upickle.ReadWriter[Seq[String]]]
-      .bimap(_.options, new JavaCompilerOptions(_))
-
-  def empty: JavaCompilerOptions = new JavaCompilerOptions(Seq.empty)
-
-  /** Constructs without filtering. */
-  def unsafe(options: Seq[String]): JavaCompilerOptions = new JavaCompilerOptions(options)
-
-  def apply(options: Seq[String]): (runtime: JavaRuntimeOptions, compiler: JavaCompilerOptions) = {
+  def split(options: Seq[String]): (runtime: Seq[String], compiler: Seq[String]) = {
     val prefix = "-J"
     val (runtimeOptions0, compilerOptions) = options.partition(_.startsWith(prefix))
-    val runtimeOptions = JavaRuntimeOptions(runtimeOptions0.map(_.drop(prefix.length)))
-    (runtimeOptions, new JavaCompilerOptions(compilerOptions))
+    val runtimeOptions = runtimeOptions0.map(_.drop(prefix.length))
+    (runtimeOptions, compilerOptions)
   }
 }
-
-/** Options that are passed to the Java runtime. */
-case class JavaRuntimeOptions(options: Seq[String])

libs/javalib/api/src/mill/javalib/api/internal/zinc_operations.scala

@@ -3,30 +3,37 @@ package mill.javalib.api.internal
 import mill.api.PathRef
 import mill.javalib.api.CompilationResult
 import mill.api.JsonFormatters.*
+import mill.api.daemon.Result
+
+sealed trait ZincOperation extends mill.rpc.MillRpcChannel.Message derives upickle.ReadWriter {}
 
 /** Compiles Java-only sources. */
 case class ZincCompileJava(
     upstreamCompileOutput: Seq[CompilationResult],
     sources: Seq[os.Path],
     compileClasspath: Seq[os.Path],
-    javacOptions: JavaCompilerOptions,
+    javacOptions: Seq[String],
     incrementalCompilation: Boolean
-) derives upickle.ReadWriter
+) extends ZincOperation {
+  type Response = Result[CompilationResult]
+}
 
 /** Compiles Java and Scala sources. */
 case class ZincCompileMixed(
     upstreamCompileOutput: Seq[CompilationResult],
     sources: Seq[os.Path],
     compileClasspath: Seq[os.Path],
-    javacOptions: JavaCompilerOptions,
+    javacOptions: Seq[String],
     scalaVersion: String,
     scalaOrganization: String,
     scalacOptions: Seq[String],
     compilerClasspath: Seq[PathRef],
     scalacPluginClasspath: Seq[PathRef],
     incrementalCompilation: Boolean,
     auxiliaryClassFileExtensions: Seq[String]
-) derives upickle.ReadWriter
+) extends ZincOperation {
+  type Response = Result[CompilationResult]
+}
 
 /** Creates a Scaladoc jar. */
 case class ZincScaladocJar(
@@ -35,21 +42,25 @@ case class ZincScaladocJar(
     compilerClasspath: Seq[PathRef],
     scalacPluginClasspath: Seq[PathRef],
     args: Seq[String]
-) derives upickle.ReadWriter
+) extends ZincOperation {
 
-case class ZincDiscoverTests(runCp: Seq[os.Path], testCp: Seq[os.Path], framework: String)
-    derives upickle.ReadWriter
+  type Response = Boolean
+}
 
+case class ZincDiscoverTests(runCp: Seq[os.Path], testCp: Seq[os.Path], framework: String)
+    extends ZincOperation {
+  type Response = Seq[String]
+}
 case class ZincGetTestTasks(
     runCp: Seq[os.Path],
     testCp: Seq[os.Path],
     framework: String,
     selectors: Seq[String],
     args: Seq[String]
-) derives upickle.ReadWriter
+) extends ZincOperation { type Response = Seq[String] }
 
 case class ZincDiscoverJunit5Tests(
     runCp: Seq[os.Path],
     testCp: Seq[os.Path],
     classesDir: Option[os.Path]
-) derives upickle.ReadWriter
+) extends ZincOperation { type Response = Seq[String] }

libs/javalib/api/test/src/mill/javalib/api/internal/JavaCompilerOptionsTests.scala

@@ -5,7 +5,7 @@ import utest.*
 object JavaCompilerOptionsTests extends TestSuite {
   val tests = Tests {
     test("apply") {
-      val options = JavaCompilerOptions(Seq(
+      val options = JavaCompilerOptions.split(Seq(
         "1",
         "2",
         "-J-Xmx1g",
@@ -18,16 +18,16 @@ object JavaCompilerOptionsTests extends TestSuite {
       ))
 
       assert(
-        options.runtime == JavaRuntimeOptions(Seq(
+        options.runtime == Seq(
           "-Xmx1g",
           "-Dfoo=bar"
 //          "-XDcompilePolicy=simple",
 //          "-processorpath", "foo",
 //          "-Xplugin:ErrorProne -XepAllErrorsAsWarnings"
-        ))
+        )
       )
 
-      assert(options.compiler == JavaCompilerOptions.unsafe(Seq("1", "2", "3", "4")))
+      assert(options.compiler == Seq("1", "2", "3", "4"))
     }
   }
 }

libs/javalib/package.mill

@@ -60,7 +60,7 @@ object `package` extends MillStableScalaModule {
   }
 
   object api extends MillStableScalaModule with BuildInfo {
-    def moduleDeps = Seq(build.core.api)
+    def moduleDeps = Seq(build.core.api, build.libs.rpc)
     def buildInfoPackageName = "mill.javalib.api"
     def buildInfoObjectName = "Versions"