Fix warning about workers not implementing AutoCloseable

contrib/flyway/src/mill/contrib/flyway/FlywayModule.scala

@@ -4,15 +4,18 @@ import mill.contrib.flyway.ConsoleLog.Level
 import org.flywaydb.core.Flyway
 import org.flywaydb.core.api.MigrationVersion
 import org.flywaydb.core.api.logging.LogFactory
-import org.flywaydb.core.internal.configuration.{ConfigUtils => flyway}
+import org.flywaydb.core.internal.configuration.ConfigUtils as flyway
 import org.flywaydb.core.internal.info.MigrationInfoDumper
-import scala.jdk.CollectionConverters._
 
+import scala.jdk.CollectionConverters.*
 import mill.*
 import mill.api.PathRef
+import mill.api.daemon.MillURLClassLoader
 import mill.javalib.{Dep, JavaModule}
 import org.flywaydb.core.api.output.{BaselineResult, CleanResult, MigrateOutput, MigrateResult}
 
+import scala.annotation.nowarn
+
 trait FlywayModule extends JavaModule {
   import FlywayModule._
 
@@ -34,10 +37,12 @@ trait FlywayModule extends JavaModule {
       .filter(_.nonEmpty)
       .map(key -> _)
 
-  def flywayClassloader = Task.Worker {
+  def flywayClassloader: Worker[MillURLClassLoader] = Task.Worker {
     mill.util.Jvm.createClassLoader(jdbcClasspath().map(_.path))
   }
-  def flywayInstance = Task.Worker {
+
+  @nowarn("msg=.*Workers should implement AutoCloseable.*")
+  def flywayInstance: Worker[Flyway] = Task.Worker {
     val jdbcClassloader = flywayClassloader()
 
     val configProps = Map(flyway.URL -> flywayUrl()) ++

contrib/playlib/src/mill/playlib/RouteCompilerWorker.scala

@@ -6,7 +6,7 @@ import mill.playlib.api.RouteCompilerType
 import mill.javalib.api.CompilationResult
 import mill.*
 
-private[playlib] class RouteCompilerWorker {
+private[playlib] class RouteCompilerWorker extends AutoCloseable {
 
   def compile(
       toolsClasspath: Seq[PathRef],
@@ -48,6 +48,10 @@ private[playlib] class RouteCompilerWorker {
         case err => Result.Failure(err)
       }
     }
+  }
 
+  override def close(): Unit = {
+    // no-op
+    // TODO: cache classloader to improve repetitive compilations
   }
 }

contrib/playlib/src/mill/playlib/RouteCompilerWorkerModule.scala

@@ -4,6 +4,7 @@ import mill.{Module, Task, Worker}
 import mill.api.{Discover, ExternalModule}
 
 trait RouteCompilerWorkerModule extends Module {
+
   def routeCompilerWorker: Worker[RouteCompilerWorker] = Task.Worker {
     new RouteCompilerWorker()
   }

contrib/scalapblib/src/mill/contrib/scalapblib/ScalaPBWorker.scala

@@ -4,7 +4,7 @@ import mill.api.PathRef
 
 import java.io.File
 
-class ScalaPBWorker {
+class ScalaPBWorker extends AutoCloseable {
 
   private def scalaPB(scalaPBClasspath: Seq[PathRef])(using ctx: mill.api.TaskCtx) = {
     val instance = new ScalaPBWorkerApi {
@@ -98,4 +98,8 @@ class ScalaPBWorker {
     )
     mill.api.Result.Success(PathRef(dest))
   }
+
+  override def close(): Unit = {
+    // no-op
+  }
 }

contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi2.java

@@ -5,7 +5,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 
-public interface ScoverageReportWorkerApi2 {
+public interface ScoverageReportWorkerApi2 extends AutoCloseable {
 
   interface Logger {
     void error(String msg);
@@ -105,4 +105,9 @@ static void makeAllDirs(Path path) throws IOException {
       Files.createDirectories(path);
     }
   }
+
+  @Override
+  default void close() throws Exception {
+    // no-op
+  }
 }

contrib/scoverage/src/mill/contrib/scoverage/ScoverageReportWorker.scala

@@ -11,7 +11,7 @@ import mill.contrib.scoverage.api.ScoverageReportWorkerApi2.{
 }
 import os.Path
 
-class ScoverageReportWorker {
+class ScoverageReportWorker extends AutoCloseable {
 
   def bridge(classpath: Seq[PathRef]): ScoverageReportWorkerApiBridge = {
     def ctx0(using ctx: TaskCtx): ApiCtx = {
@@ -74,6 +74,10 @@ class ScoverageReportWorker {
       ))
     }
   }
+
+  override def close(): Unit = {
+    // no-op
+  }
 }
 
 object ScoverageReportWorker extends ExternalModule {
@@ -101,5 +105,7 @@ object ScoverageReportWorker extends ExternalModule {
 
   def scoverageReportWorker: Task.Worker[ScoverageReportWorker] =
     Task.Worker { new ScoverageReportWorker() }
+
+  // TODO: make protected
   lazy val millDiscover = Discover[this.type]
 }

libs/androidlib/databinding/src/mill/androidlib/databinding/AndroidDataBindingWorker.scala

@@ -1,6 +1,12 @@
 package mill.androidlib.databinding
 
-trait AndroidDataBindingWorker {
+trait AndroidDataBindingWorker extends AutoCloseable {
+
   def processResources(args: ProcessResourcesArgs): Unit
+
   def generateBindingSources(args: GenerateBindingSourcesArgs): Unit
+
+  override def close(): Unit = {
+    // no-up
+  }
 }

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

@@ -9,7 +9,7 @@ import mill.javalib.api.JvmWorkerApi.Ctx
 import mill.javalib.api.internal.ZincOp
 import os.Path
 
-trait InternalJvmWorkerApi extends PublicJvmWorkerApi {
+trait InternalJvmWorkerApi extends PublicJvmWorkerApi, AutoCloseable {
 
   /** Compile a Java-only project. */
   def apply(
@@ -119,7 +119,12 @@ trait InternalJvmWorkerApi extends PublicJvmWorkerApi {
       reportCachedProblems = false
     )
   }
+
+  override def close(): Unit = {
+    // bin-compat shim
+  }
 }
+
 object InternalJvmWorkerApi {
   type Ctx = PublicJvmWorkerApi.Ctx
 }

libs/javalib/api/src/mill/javalib/classgraph/ClassgraphWorker.scala

@@ -2,6 +2,10 @@ package mill.javalib.classgraph
 
 import mill.api.TaskCtx
 
-trait ClassgraphWorker {
+trait ClassgraphWorker extends AutoCloseable {
   def discoverMainClasses(classpath: Seq[os.Path])(using ctx: TaskCtx): Seq[String]
+
+  override def close(): Unit = {
+    // noop
+  }
 }

libs/javalib/src/mill/javalib/MavenWorkerSupport.scala

@@ -5,6 +5,8 @@ import mill.javalib.publish.{Artifact, PublishInfo}
 import mill.util.Jvm
 import os.Path
 
+import scala.annotation.nowarn
+
 private[mill] trait MavenWorkerSupport extends CoursierModule with OfflineSupportModule {
   private def mavenWorkerClasspath: T[Seq[PathRef]] = Task {
     defaultResolver().classpath(Seq(
@@ -21,6 +23,7 @@ private[mill] trait MavenWorkerSupport extends CoursierModule with OfflineSuppor
     Jvm.createClassLoader(classPath = classPath, parent = getClass.getClassLoader)
   }
 
+  @nowarn("msg=.*Workers should implement AutoCloseable.*")
   private[mill] def mavenWorker: Task.Worker[mill.javalib.internal.MavenWorkerSupport.Api] =
     Task.Worker {
       mavenWorkerClassloader().loadClass("mill.javalib.maven.worker.impl.WorkerImpl")

libs/kotlinlib/ksp2-api/src/mill/kotlinlib/ksp2/KspWorker.scala

@@ -1,11 +1,15 @@
 package mill.kotlinlib.ksp2
 
-trait KspWorker {
+trait KspWorker extends AutoCloseable {
 
   def runKsp(
       symbolProcessorClassloader: ClassLoader,
       kspWorkerArgs: KspWorkerArgs,
       symbolProcessingArgs: Seq[String]
   ): Unit
 
+  override def close(): Unit = {
+    // no-op
+  }
+
 }

libs/util/src/mill/util/VisualizeModule.scala

@@ -2,14 +2,16 @@ package mill.util
 
 import java.util.concurrent.LinkedBlockingQueue
 import coursier.core.Repository
-import mill.api.{PathRef, Discover, Evaluator, ExternalModule, MultiBiMap, SelectMode}
+import mill.api.{Discover, Evaluator, ExternalModule, MultiBiMap, PathRef, SelectMode}
 import mill.*
-import mill.api.{Result}
+import mill.api.Result
 import org.jgrapht.graph.{DefaultEdge, SimpleDirectedGraph}
 import guru.nidi.graphviz.attribute.Rank.RankDir
 import guru.nidi.graphviz.attribute.{Rank, Shape, Style}
 import mill.api.BuildCtx
 
+import scala.annotation.nowarn
+
 object VisualizeModule extends ExternalModule {
   def repositories: Seq[Repository] =
     coursier.Resolve.defaultRepositories
@@ -62,6 +64,7 @@ object VisualizeModule extends ExternalModule {
     }
   }
 
+  // TODO: Remove bin-compat shim in Mill 2.x
   @deprecated("Use toolsClasspath instead", "0.13.0-M1")
   def classpath = toolsClasspath
 
@@ -88,6 +91,7 @@ object VisualizeModule extends ExternalModule {
    * everyone can use to call into Graphviz, which the Mill execution threads
    * can communicate via in/out queues.
    */
+  @nowarn("msg=.*Workers should implement AutoCloseable.*")
   private[mill] def worker: Worker[(
       LinkedBlockingQueue[(
           scala.Seq[Task.Named[Any]],