From 7da02654a3f6631dfb0847f81fac42c80b6c2723 Mon Sep 17 00:00:00 2001
From: Li Haoyi <haoyi.sg@gmail.com>
Date: Sat, 12 Oct 2024 08:59:26 +0200
Subject: [PATCH] Cherry-pick source compatible Scala 3 changes (#3721)

Pulls in some changes from https://github.com/com-lihaoyi/mill/pull/3369
to try and reduce the size of that diff and simplify future backports
---
 .../src/mill/bsp/worker/MillBuildServer.scala |  2 +-
 bsp/worker/src/mill/bsp/worker/Utils.scala    |  2 +-
 build.mill                                    |  1 +
 .../mill/contrib/buildinfo/BuildInfo.scala    |  2 +-
 .../src/mill/playlib/RouterModule.scala       |  1 +
 .../playlib/src/mill/playlib/Version.scala    |  4 +-
 .../src/mill/playlib/PlayModuleTests.scala    |  3 +-
 .../api/ScoverageReportWorkerApi.scala        | 46 ---------
 .../api/ScoverageReportWorkerApi2.java        | 95 +++++++++++++++++++
 .../contrib/scoverage/ScoverageModule.scala   |  2 +-
 .../contrib/scoverage/ScoverageReport.scala   |  2 +-
 .../scoverage/ScoverageReportWorker.scala     | 65 +++++++++++--
 .../worker/ScoverageReportWorkerImpl.scala    | 32 ++++---
 .../src/mill/twirllib/TwirlModule.scala       |  4 +-
 .../src/mill/twirllib/HelloWorldTests.scala   | 13 ++-
 example/thirdparty/mockito/build.mill         | 14 +++
 example/thirdparty/netty/build.mill           |  4 +-
 .../src/DocAnnotationsTests.scala             |  2 +-
 .../mill-build/mill-build/build.mill          |  2 +-
 .../src/MultiLevelBuildTests.scala            | 34 +++----
 main/api/src/mill/api/AggWrapper.scala        | 13 +--
 main/api/src/mill/api/ClassLoader.scala       |  2 +-
 main/api/src/mill/api/Ctx.scala               |  8 +-
 main/api/src/mill/api/FixSizedCache.scala     |  2 +-
 main/api/src/mill/api/JarOps.scala            |  6 +-
 main/api/src/mill/api/JsonFormatters.scala    |  2 +-
 main/api/src/mill/api/KeyedLockedCache.scala  |  2 +-
 main/api/src/mill/api/PathRef.scala           |  6 +-
 main/api/src/mill/api/Result.scala            | 18 ++--
 main/api/src/mill/api/Retry.scala             |  4 +-
 main/api/src/mill/api/SystemStreams.scala     |  6 +-
 main/codesig/package.mill                     |  3 +-
 main/codesig/src/JvmModel.scala               |  2 +-
 main/codesig/src/ResolvedCalls.scala          |  4 +-
 main/codesig/src/SpanningForest.scala         |  6 +-
 .../basic/17-scala-lambda/src/Hello.scala     |  7 +-
 .../src/Hello.scala                           |  5 +-
 .../6-classes-misc-scala/src/Hello.scala      |  2 +-
 .../8-linked-list-scala/src/Hello.scala       |  4 +-
 .../realistic/5-parser/src/Hello.scala        | 10 +-
 .../test/src/mill/define/BasePathTests.scala  | 20 ++--
 main/eval/src/mill/eval/EvaluatorCore.scala   | 37 ++++----
 main/eval/src/mill/eval/GroupEvaluator.scala  |  4 +-
 .../test/src/mill/eval/EvaluationTests.scala  | 47 ++++-----
 main/init/src/mill/init/InitModule.scala      |  5 +-
 main/package.mill                             | 18 +++-
 .../src/mill/resolve/ExpandBraces.scala       |  2 +-
 main/resolve/src/mill/resolve/ParseArgs.scala |  2 +-
 .../mill/resolve/ResolveNotFoundHandler.scala |  6 +-
 main/server/src/mill/main/server/Server.scala |  3 +-
 main/src/mill/main/MainModule.scala           |  4 +-
 main/src/mill/main/TokenReaders.scala         |  1 +
 main/util/src/mill/util/PrefixLogger.scala    |  6 +-
 .../src/mill/scalajslib/ScalaJSModule.scala   |  4 +-
 .../mill/scalajslib/CompileLinkTests.scala    |  9 +-
 .../mill/scalajslib/EsModuleRemapTests.scala  | 10 +-
 .../scalajslib/FullOptESModuleTests.scala     |  5 +-
 .../mill/scalajslib/MultiModuleTests.scala    |  5 +-
 .../mill/scalajslib/NodeJSConfigTests.scala   |  7 +-
 .../mill/scalajslib/OutputPatternsTests.scala |  5 +-
 .../scalajslib/ScalaTestsErrorTests.scala     |  5 +-
 .../scalajslib/SmallModulesForTests.scala     |  5 +-
 .../src/mill/scalajslib/SourceMapTests.scala  |  5 +-
 .../scalajslib/TopLevelExportsTests.scala     |  5 +-
 .../src/mill/scalalib/CrossSbtModule.scala    |  1 -
 scalalib/src/mill/scalalib/Dep.scala          |  8 +-
 scalalib/src/mill/scalalib/JavaModule.scala   |  6 +-
 .../src/mill/scalalib/PublishModule.scala     |  6 +-
 scalalib/src/mill/scalalib/ScalaModule.scala  |  5 +-
 .../src/mill/scalalib/ZincWorkerModule.scala  |  1 -
 .../dependency/updates/UpdatesFinder.scala    |  2 +-
 .../dependency/versions/VersionParser.scala   |  2 +-
 .../mill/scalalib/giter8/Giter8Module.scala   | 21 +++-
 .../mill/scalalib/publish/VersionScheme.scala |  3 +-
 .../mill/scalanativelib/CompileRunTests.scala |  2 +-
 .../mill/scalanativelib/ExclusionsTests.scala |  1 +
 .../mill/scalanativelib/FeaturesTests.scala   |  1 +
 .../scalanativelib/ScalaTestsErrorTests.scala |  5 +-
 .../src/mill/testkit/IntegrationTester.scala  |  2 +-
 testkit/src/mill/testkit/UnitTester.scala     |  2 +-
 80 files changed, 477 insertions(+), 253 deletions(-)
 delete mode 100644 contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi.scala
 create mode 100644 contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi2.java

diff --git a/bsp/worker/src/mill/bsp/worker/MillBuildServer.scala b/bsp/worker/src/mill/bsp/worker/MillBuildServer.scala
index 727be75c932..23ec8ca7d39 100644
--- a/bsp/worker/src/mill/bsp/worker/MillBuildServer.scala
+++ b/bsp/worker/src/mill/bsp/worker/MillBuildServer.scala
@@ -632,7 +632,7 @@ private class MillBuildServer(
       State
   ) => V): CompletableFuture[V] = {
     val prefix = hint.split(" ").head
-    completable(hint) { state: State =>
+    completable(hint) { (state: State) =>
       val ids = state.filterNonSynthetic(targetIds(state).asJava).asScala
       val tasksSeq = ids.flatMap { id =>
         val (m, ev) = state.bspModulesById(id)
diff --git a/bsp/worker/src/mill/bsp/worker/Utils.scala b/bsp/worker/src/mill/bsp/worker/Utils.scala
index 5fe3f57b190..7b96c76a88e 100644
--- a/bsp/worker/src/mill/bsp/worker/Utils.scala
+++ b/bsp/worker/src/mill/bsp/worker/Utils.scala
@@ -34,7 +34,7 @@ private object Utils {
       originId: String,
       bspIdsByModule: Map[BspModule, BuildTargetIdentifier],
       client: BuildClient
-  ): Int => Option[CompileProblemReporter] = { moduleHashCode: Int =>
+  ): Int => Option[CompileProblemReporter] = { (moduleHashCode: Int) =>
     bspIdsByModule.find(_._1.hashCode == moduleHashCode).map {
       case (module: JavaModule, targetId) =>
         val buildTarget = module.bspBuildTarget
diff --git a/build.mill b/build.mill
index 60b3afa4be7..365a2225c13 100644
--- a/build.mill
+++ b/build.mill
@@ -56,6 +56,7 @@ object Deps {
   // When updating, run "Publish Bridges" Github Actions for the new version
   // and then add to it `bridgeScalaVersions`
   val scalaVersion = "2.13.14"
+  val scala2Version = "2.13.14"
   // The Scala 2.12.x version to use for some workers
   val workerScalaVersion212 = "2.12.19"
 
diff --git a/contrib/buildinfo/src/mill/contrib/buildinfo/BuildInfo.scala b/contrib/buildinfo/src/mill/contrib/buildinfo/BuildInfo.scala
index 2f83bc60050..dcd6f0d8bce 100644
--- a/contrib/buildinfo/src/mill/contrib/buildinfo/BuildInfo.scala
+++ b/contrib/buildinfo/src/mill/contrib/buildinfo/BuildInfo.scala
@@ -173,7 +173,7 @@ object BuildInfo {
          |package ${buildInfoPackageName}
          |
          |object $buildInfoObjectName {
-         |  private[this] val buildInfoProperties: java.util.Properties = new java.util.Properties()
+         |  private val buildInfoProperties: java.util.Properties = new java.util.Properties()
          |
          |  {
          |    val buildInfoInputStream = getClass
diff --git a/contrib/playlib/src/mill/playlib/RouterModule.scala b/contrib/playlib/src/mill/playlib/RouterModule.scala
index fdfeaa2605f..11b921257b5 100644
--- a/contrib/playlib/src/mill/playlib/RouterModule.scala
+++ b/contrib/playlib/src/mill/playlib/RouterModule.scala
@@ -80,6 +80,7 @@ trait RouterModule extends ScalaModule with Version {
       repositoriesTask(),
       artifactSuffix = playMinorVersion() match {
         case "2.6" => "_2.12"
+        case "2.7" | "2.8" => "_2.13"
         case _ => "_2.13"
       }
     )
diff --git a/contrib/playlib/src/mill/playlib/Version.scala b/contrib/playlib/src/mill/playlib/Version.scala
index c129d3820cf..a9640fac8ee 100644
--- a/contrib/playlib/src/mill/playlib/Version.scala
+++ b/contrib/playlib/src/mill/playlib/Version.scala
@@ -12,11 +12,11 @@ private[playlib] trait Version extends Module {
     playVersion().split('.').take(2).mkString(".")
   }
 
-  private[playlib] def playOrganization: T[String] = Task.Anon {
+  private[playlib] def playOrganization: Task[String] = Task.Anon {
     if (playVersion().startsWith("2.")) "com.typesafe.play" else "org.playframework"
   }
 
-  private[playlib] def component(id: String) = Task.Anon {
+  private[playlib] def component(id: String): Task[Dep] = Task.Anon {
     ivy"${playOrganization()}::$id::${playVersion()}"
   }
 }
diff --git a/contrib/playlib/test/src/mill/playlib/PlayModuleTests.scala b/contrib/playlib/test/src/mill/playlib/PlayModuleTests.scala
index afd219fcd7c..a6a97db4d6f 100644
--- a/contrib/playlib/test/src/mill/playlib/PlayModuleTests.scala
+++ b/contrib/playlib/test/src/mill/playlib/PlayModuleTests.scala
@@ -1,6 +1,7 @@
 package mill
 package playlib
 
+import mill.scalalib.api.ZincWorkerUtil
 import mill.testkit.{TestBaseModule, UnitTester}
 import utest.{TestSuite, Tests, assert, _}
 
@@ -102,7 +103,7 @@ object PlayModuleTests extends TestSuite with PlayTestSuite {
               os.RelPath("controllers/routes$javascript.class"),
               os.RelPath("controllers/javascript/ReverseHomeController.class"),
               os.RelPath("controllers/javascript/ReverseAssets.class"),
-              if (scalaVersion.startsWith("3.")) os.RelPath("router/Routes$$anon$1.class")
+              if (ZincWorkerUtil.isScala3(scalaVersion)) os.RelPath("router/Routes$$anon$1.class")
               else os.RelPath("router/Routes$$anonfun$routes$1.class"),
               os.RelPath("router/Routes.class"),
               os.RelPath("router/RoutesPrefix$.class"),
diff --git a/contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi.scala b/contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi.scala
deleted file mode 100644
index 55fc01d3dc7..00000000000
--- a/contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-package mill.contrib.scoverage.api
-
-import mill.api.Ctx
-
-trait ScoverageReportWorkerApi {
-  import ScoverageReportWorkerApi._
-
-  @deprecated("Use other overload instead.", "Mill after 0.10.7")
-  def report(
-      reportType: ReportType,
-      sources: Seq[os.Path],
-      dataDirs: Seq[os.Path]
-  )(implicit
-      ctx: Ctx
-  ): Unit = {
-    report(reportType, sources, dataDirs, ctx.workspace)
-  }
-
-  def report(
-      reportType: ReportType,
-      sources: Seq[os.Path],
-      dataDirs: Seq[os.Path],
-      sourceRoot: os.Path
-  )(implicit
-      ctx: Ctx
-  ): Unit = {
-    // FIXME: We only call the deprecated version here, to preserve binary compatibility. Remove when appropriate.
-    ctx.log.error(
-      "Binary compatibility stub may cause infinite loops with StackOverflowError. You need to implement: def report(ReportType, Seq[Path], Seq[Path], os.Path): Unit"
-    )
-    report(reportType, sources, dataDirs)
-  }
-}
-
-object ScoverageReportWorkerApi {
-  sealed trait ReportType
-  sealed trait FileReportType extends ReportType { def folderName: String }
-  object ReportType {
-    final case object Html extends FileReportType { val folderName: String = "htmlReport" }
-    final case object Xml extends FileReportType { val folderName: String = "xmlReport" }
-    final case object XmlCobertura extends FileReportType {
-      val folderName: String = "xmlCoberturaReport"
-    }
-    final case object Console extends ReportType
-  }
-}
diff --git a/contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi2.java b/contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi2.java
new file mode 100644
index 00000000000..09868af8b3e
--- /dev/null
+++ b/contrib/scoverage/api/src/mill/contrib/scoverage/api/ScoverageReportWorkerApi2.java
@@ -0,0 +1,95 @@
+package mill.contrib.scoverage.api;
+
+import java.nio.file.Path;
+import java.nio.file.Files;
+import java.io.IOException;
+import java.io.Serializable;
+
+public interface ScoverageReportWorkerApi2 {
+
+  interface Logger {
+    void info(String msg);
+    void error(String msg);
+    void debug(String msg);
+  }
+
+  interface Ctx {
+    Logger log();
+    Path dest();
+  }
+
+  public static abstract class ReportType implements Serializable {
+    private String name;
+
+    /*private[api]*/
+    ReportType(String name) {}
+
+    public static final ReportType Console = new ConsoleModule();
+    public static final FileReportType Html = new HtmlModule();
+    public static final FileReportType Xml = new XmlModule();
+    public static final FileReportType XmlCobertura = new XmlCoberturaModule();
+
+    /* private[api]*/
+    static final class ConsoleModule extends ReportType implements Serializable {
+      /* private[api]*/
+      ConsoleModule() {
+        super("Console");
+      }
+    };
+
+    /* private[api]*/
+    static final class HtmlModule extends FileReportType implements Serializable {
+      /* private[api]*/
+      HtmlModule() {
+        super("Html", "htmlReport");
+      }
+    };
+
+    /* private[api]*/
+    static final class XmlModule extends FileReportType implements Serializable {
+      /* private[api]*/
+      XmlModule() {
+        super("Xml", "xmlReport");
+      }
+    }
+
+    /* private[api]*/
+    static final class XmlCoberturaModule extends FileReportType implements Serializable {
+      /* private[api]*/
+      XmlCoberturaModule() {
+        super("XmlCobertura", "xmlCoberturaReport");
+      }
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  public static abstract class FileReportType extends ReportType implements Serializable {
+    private final String folderName;
+
+    /*private[api]*/
+    FileReportType(String name, String folderName) {
+      super(name);
+      this.folderName = folderName;
+    }
+
+    public String folderName() {
+      return folderName;
+    }
+  }
+
+  void report(ReportType reportType, Path[] sources, Path[] dataDirs, Path sourceRoot, Ctx ctx);
+
+  static void makeAllDirs(Path path) throws IOException {
+    // Replicate behavior of `os.makeDir.all(path)`
+    if (Files.isDirectory(path) && Files.isSymbolicLink(path)) {
+      // do nothing
+    } else {
+      Files.createDirectories(path);
+    }
+  }
+
+}
diff --git a/contrib/scoverage/src/mill/contrib/scoverage/ScoverageModule.scala b/contrib/scoverage/src/mill/contrib/scoverage/ScoverageModule.scala
index fba21cb2ccd..e7824a266b0 100644
--- a/contrib/scoverage/src/mill/contrib/scoverage/ScoverageModule.scala
+++ b/contrib/scoverage/src/mill/contrib/scoverage/ScoverageModule.scala
@@ -3,7 +3,7 @@ package mill.contrib.scoverage
 import coursier.Repository
 import mill._
 import mill.api.{Loose, PathRef, Result}
-import mill.contrib.scoverage.api.ScoverageReportWorkerApi.ReportType
+import mill.contrib.scoverage.api.ScoverageReportWorkerApi2.ReportType
 import mill.main.BuildInfo
 import mill.scalalib.api.ZincWorkerUtil
 import mill.scalalib.{Dep, DepSyntax, JavaModule, ScalaModule}
diff --git a/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReport.scala b/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReport.scala
index fd25e64e3da..e7c6ed5670f 100644
--- a/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReport.scala
+++ b/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReport.scala
@@ -1,6 +1,6 @@
 package mill.contrib.scoverage
 
-import mill.contrib.scoverage.api.ScoverageReportWorkerApi.ReportType
+import mill.contrib.scoverage.api.ScoverageReportWorkerApi2.ReportType
 import mill.define.{Command, Module, Task}
 import mill.eval.Evaluator
 import mill.resolve.{Resolve, SelectMode}
diff --git a/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReportWorker.scala b/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReportWorker.scala
index 799ed317178..600c90d3bb9 100644
--- a/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReportWorker.scala
+++ b/contrib/scoverage/src/mill/contrib/scoverage/ScoverageReportWorker.scala
@@ -2,13 +2,18 @@ package mill.contrib.scoverage
 
 import mill.{Agg, Task}
 import mill.api.{ClassLoader, Ctx, PathRef}
-import mill.contrib.scoverage.api.ScoverageReportWorkerApi
+import mill.contrib.scoverage.api.ScoverageReportWorkerApi2
 import mill.define.{Discover, ExternalModule, Worker}
 
+import ScoverageReportWorker.ScoverageReportWorkerApiBridge
+import ScoverageReportWorkerApi2.ReportType
+import ScoverageReportWorkerApi2.{Logger => ApiLogger}
+import ScoverageReportWorkerApi2.{Ctx => ApiCtx}
+
 class ScoverageReportWorker extends AutoCloseable {
-  private[this] var scoverageClCache = Option.empty[(Long, ClassLoader)]
+  private var scoverageClCache = Option.empty[(Long, ClassLoader)]
 
-  def bridge(classpath: Agg[PathRef])(implicit ctx: Ctx): ScoverageReportWorkerApi = {
+  def bridge(classpath: Agg[PathRef])(implicit ctx: Ctx): ScoverageReportWorkerApiBridge = {
 
     val classloaderSig = classpath.hashCode
     val cl = scoverageClCache match {
@@ -24,11 +29,43 @@ class ScoverageReportWorker extends AutoCloseable {
         cl
     }
 
-    cl
-      .loadClass("mill.contrib.scoverage.worker.ScoverageReportWorkerImpl")
-      .getDeclaredConstructor()
-      .newInstance()
-      .asInstanceOf[api.ScoverageReportWorkerApi]
+    val worker =
+      cl
+        .loadClass("mill.contrib.scoverage.worker.ScoverageReportWorkerImpl")
+        .getDeclaredConstructor()
+        .newInstance()
+        .asInstanceOf[api.ScoverageReportWorkerApi2]
+
+    def ctx0(implicit ctx: Ctx): ApiCtx = {
+      val logger = new ApiLogger {
+        def info(msg: String): Unit = ctx.log.info(msg)
+        def error(msg: String): Unit = ctx.log.error(msg)
+        def debug(msg: String): Unit = ctx.log.debug(msg)
+      }
+      new ApiCtx {
+        def log() = logger
+        def dest() = ctx.dest.toNIO
+      }
+    }
+
+    new ScoverageReportWorkerApiBridge {
+      override def report(
+          reportType: ReportType,
+          sources: Seq[os.Path],
+          dataDirs: Seq[os.Path],
+          sourceRoot: os.Path
+      )(implicit
+          ctx: Ctx
+      ): Unit = {
+        worker.report(
+          reportType,
+          sources.map(_.toNIO).toArray,
+          dataDirs.map(_.toNIO).toArray,
+          sourceRoot.toNIO,
+          ctx0
+        )
+      }
+    }
   }
 
   override def close(): Unit = {
@@ -37,6 +74,18 @@ class ScoverageReportWorker extends AutoCloseable {
 }
 
 object ScoverageReportWorker extends ExternalModule {
+  import ScoverageReportWorkerApi2.ReportType
+
+  trait ScoverageReportWorkerApiBridge {
+    def report(
+        reportType: ReportType,
+        sources: Seq[os.Path],
+        dataDirs: Seq[os.Path],
+        sourceRoot: os.Path
+    )(implicit
+        ctx: Ctx
+    ): Unit
+  }
 
   def scoverageReportWorker: Worker[ScoverageReportWorker] =
     Task.Worker { new ScoverageReportWorker() }
diff --git a/contrib/scoverage/worker2/src/mill/contrib/scoverage/worker/ScoverageReportWorkerImpl.scala b/contrib/scoverage/worker2/src/mill/contrib/scoverage/worker/ScoverageReportWorkerImpl.scala
index a478a91c533..1393af627f1 100644
--- a/contrib/scoverage/worker2/src/mill/contrib/scoverage/worker/ScoverageReportWorkerImpl.scala
+++ b/contrib/scoverage/worker2/src/mill/contrib/scoverage/worker/ScoverageReportWorkerImpl.scala
@@ -1,42 +1,46 @@
 package mill.contrib.scoverage.worker
 
-import mill.contrib.scoverage.api.ScoverageReportWorkerApi
 import _root_.scoverage.reporter.{
   CoberturaXmlWriter,
   CoverageAggregator,
   ScoverageHtmlWriter,
   ScoverageXmlWriter
 }
-import mill.api.Ctx
-import mill.contrib.scoverage.api.ScoverageReportWorkerApi.ReportType
+
+import mill.contrib.scoverage.api.ScoverageReportWorkerApi2
+import ScoverageReportWorkerApi2.ReportType
+import ScoverageReportWorkerApi2.Ctx
+
+import java.nio.file.Path
 
 /**
  * Scoverage Worker for Scoverage 2.x
  */
-class ScoverageReportWorkerImpl extends ScoverageReportWorkerApi {
+class ScoverageReportWorkerImpl extends ScoverageReportWorkerApi2 {
 
   override def report(
       reportType: ReportType,
-      sources: Seq[os.Path],
-      dataDirs: Seq[os.Path],
-      sourceRoot: os.Path
-  )(implicit ctx: Ctx): Unit =
+      sources: Array[Path],
+      dataDirs: Array[Path],
+      sourceRoot: Path,
+      ctx: Ctx
+  ): Unit =
     try {
       ctx.log.info(s"Processing coverage data for ${dataDirs.size} data locations")
-      CoverageAggregator.aggregate(dataDirs.map(_.toIO), sourceRoot.toIO) match {
+      CoverageAggregator.aggregate(dataDirs.map(_.toFile).toIndexedSeq, sourceRoot.toFile) match {
         case Some(coverage) =>
-          val sourceFolders = sources.map(_.toIO)
+          val sourceFolders = sources.map(_.toFile).toIndexedSeq
           val folder = ctx.dest
-          os.makeDir.all(folder)
+          ScoverageReportWorkerApi2.makeAllDirs(folder)
           reportType match {
             case ReportType.Html =>
-              new ScoverageHtmlWriter(sourceFolders, folder.toIO, None)
+              new ScoverageHtmlWriter(sourceFolders, folder.toFile, None)
                 .write(coverage)
             case ReportType.Xml =>
-              new ScoverageXmlWriter(sourceFolders, folder.toIO, false, None)
+              new ScoverageXmlWriter(sourceFolders, folder.toFile, false, None)
                 .write(coverage)
             case ReportType.XmlCobertura =>
-              new CoberturaXmlWriter(sourceFolders, folder.toIO, None)
+              new CoberturaXmlWriter(sourceFolders, folder.toFile, None)
                 .write(coverage)
             case ReportType.Console =>
               ctx.log.info(s"Statement coverage.: ${coverage.statementCoverageFormatted}%")
diff --git a/contrib/twirllib/src/mill/twirllib/TwirlModule.scala b/contrib/twirllib/src/mill/twirllib/TwirlModule.scala
index c2d6fad03b8..0c3269e78c2 100644
--- a/contrib/twirllib/src/mill/twirllib/TwirlModule.scala
+++ b/contrib/twirllib/src/mill/twirllib/TwirlModule.scala
@@ -33,7 +33,7 @@ trait TwirlModule extends mill.Module { twirlModule =>
    * Replicate the logic from twirl build,
    *      see: https://github.com/playframework/twirl/blob/2.0.1/build.sbt#L12-L17
    */
-  private def scalaParserCombinatorsVersion: T[String] = twirlScalaVersion.map {
+  private def scalaParserCombinatorsVersion: Task[String] = twirlScalaVersion.map {
     case v if v.startsWith("2.") => "1.1.2"
     case _ => "2.3.0"
   }
@@ -57,7 +57,7 @@ trait TwirlModule extends mill.Module { twirlModule =>
    * @since Mill after 0.10.5
    */
   trait TwirlResolver extends CoursierModule {
-    override def resolveCoursierDependency: Task[Dep => Dependency] = Task.Anon { d: Dep =>
+    override def resolveCoursierDependency: Task[Dep => Dependency] = Task.Anon { (d: Dep) =>
       Lib.depToDependency(d, twirlScalaVersion())
     }
 
diff --git a/contrib/twirllib/test/src/mill/twirllib/HelloWorldTests.scala b/contrib/twirllib/test/src/mill/twirllib/HelloWorldTests.scala
index a8094cc725b..36b0b02c063 100644
--- a/contrib/twirllib/test/src/mill/twirllib/HelloWorldTests.scala
+++ b/contrib/twirllib/test/src/mill/twirllib/HelloWorldTests.scala
@@ -7,6 +7,7 @@ import utest.{TestSuite, Tests, assert, _}
 
 trait HelloWorldTests extends TestSuite {
   val testTwirlVersion: String
+  val wildcard: String
 
   trait HelloWorldModule extends mill.twirllib.TwirlModule {
     def twirlVersion = testTwirlVersion
@@ -39,8 +40,8 @@ trait HelloWorldTests extends TestSuite {
   )
 
   def expectedDefaultImports: Seq[String] = Seq(
-    "import _root_.play.twirl.api.TwirlFeatureImports._",
-    "import _root_.play.twirl.api.TwirlHelperImports._",
+    s"import _root_.play.twirl.api.TwirlFeatureImports.$wildcard",
+    s"import _root_.play.twirl.api.TwirlHelperImports.$wildcard",
     "import _root_.play.twirl.api.Html",
     "import _root_.play.twirl.api.JavaScript",
     "import _root_.play.twirl.api.Txt",
@@ -48,8 +49,8 @@ trait HelloWorldTests extends TestSuite {
   )
 
   def testAdditionalImports: Seq[String] = Seq(
-    "mill.twirl.test.AdditionalImport1._",
-    "mill.twirl.test.AdditionalImport2._"
+    s"mill.twirl.test.AdditionalImport1.$wildcard",
+    s"mill.twirl.test.AdditionalImport2.$wildcard"
   )
 
   def testConstructorAnnotations = Seq(
@@ -159,13 +160,17 @@ trait HelloWorldTests extends TestSuite {
 
 object HelloWorldTests1_3 extends HelloWorldTests {
   override val testTwirlVersion = "1.3.16"
+  override val wildcard = "_"
 }
 object HelloWorldTests1_5 extends HelloWorldTests {
   override val testTwirlVersion = "1.5.2"
+  override val wildcard = "_"
 }
 object HelloWorldTests1_6 extends HelloWorldTests {
   override val testTwirlVersion = "1.6.2"
+  override val wildcard = "_"
 }
 object HelloWorldTests2_0 extends HelloWorldTests {
   override val testTwirlVersion = "2.0.1"
+  override val wildcard = "_"
 }
diff --git a/example/thirdparty/mockito/build.mill b/example/thirdparty/mockito/build.mill
index 0af38beb6ad..ad0fbf5e3b1 100644
--- a/example/thirdparty/mockito/build.mill
+++ b/example/thirdparty/mockito/build.mill
@@ -42,11 +42,20 @@ trait MockitoModule extends MavenModule{
   def testRuntimeIvyDeps: T[Agg[Dep]] = Agg.empty[Dep]
   def testFramework = "com.novocode.junit.JUnitFramework"
   def testForkArgs: T[Seq[String]] = Seq.empty[String]
+
+  def testFilteredSources: T[Seq[PathRef]] = Task { Seq.empty[PathRef] }
+
   object test extends MavenTests{
     def moduleDeps = super.moduleDeps ++ MockitoModule.this.testModuleDeps
     def testFramework = MockitoModule.this.testFramework
     def runIvyDeps = testRuntimeIvyDeps()
     def forkArgs = testForkArgs()
+    def allSourceFiles = Task {
+      val base = super.allSourceFiles()
+      val filtered = testFilteredSources().toSet
+      if (filtered.isEmpty) base
+      else base.filterNot(filtered.contains)
+    }
     def ivyDeps =
       testIvyDeps() ++
       Agg(
@@ -85,6 +94,11 @@ object `package` extends RootModule with MockitoModule{
     super.resources() ++ Seq(PathRef(Task.dest))
   }
 
+  def testFilteredSources: T[Seq[PathRef]] = Task {
+    // test `add_listeners_concurrently_sanity_check` is flaky
+    Seq(PathRef(millSourcePath / "src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java"))
+  }
+
   object subprojects extends Module {
     object android extends MockitoModule {
       def moduleDeps = Seq(build)
diff --git a/example/thirdparty/netty/build.mill b/example/thirdparty/netty/build.mill
index f7b10579034..b9a1a7f3099 100644
--- a/example/thirdparty/netty/build.mill
+++ b/example/thirdparty/netty/build.mill
@@ -253,8 +253,8 @@ object common extends NettyModule{
     val shell = new groovy.lang.GroovyShell()
 
     val context = new java.util.HashMap[String, Object]
-    context.put("collection.template.dir", Task.workspace + "/common/src/main/templates")
-    context.put("collection.template.test.dir", Task.workspace + "/common/src/test/templates")
+    context.put("collection.template.dir", s"${Task.workspace}/common/src/main/templates")
+    context.put("collection.template.test.dir", s"${Task.workspace}/common/src/test/templates")
     context.put("collection.src.dir", (Task.dest / "src").toString)
     context.put("collection.testsrc.dir", (Task.dest / "testsrc").toString)
     shell.setProperty("properties", context)
diff --git a/integration/feature/docannotations/src/DocAnnotationsTests.scala b/integration/feature/docannotations/src/DocAnnotationsTests.scala
index 4ef2900e86c..ee3449a00ea 100644
--- a/integration/feature/docannotations/src/DocAnnotationsTests.scala
+++ b/integration/feature/docannotations/src/DocAnnotationsTests.scala
@@ -93,7 +93,7 @@ object DocAnnotationsTests extends UtestIntegrationTestSuite {
 
       assert(
         globMatches(
-          """core.ivyDepsTree(JavaModule.scala:896)
+          """core.ivyDepsTree(JavaModule.scala:...)
             |    Command to print the transitive dependency tree to STDOUT.
             |
             |    --inverse                Invert the tree representation, so that the root is on the bottom val
diff --git a/integration/invalidation/multi-level-editing/resources/mill-build/mill-build/build.mill b/integration/invalidation/multi-level-editing/resources/mill-build/mill-build/build.mill
index 7d6f134d94e..4efe9a06fcd 100644
--- a/integration/invalidation/multi-level-editing/resources/mill-build/mill-build/build.mill
+++ b/integration/invalidation/multi-level-editing/resources/mill-build/mill-build/build.mill
@@ -8,7 +8,7 @@ object `package` extends MillBuildRootModule {
       Task.dest / "MetaConstant.scala",
       """package constant
         |object MetaConstant{
-        |  def scalatagsVersion = "0.8.2"
+        |  def scalatagsVersion = "0.13.1"
         |}
         |""".stripMargin
     )
diff --git a/integration/invalidation/multi-level-editing/src/MultiLevelBuildTests.scala b/integration/invalidation/multi-level-editing/src/MultiLevelBuildTests.scala
index ba9554d6c7a..7c92a4486d4 100644
--- a/integration/invalidation/multi-level-editing/src/MultiLevelBuildTests.scala
+++ b/integration/invalidation/multi-level-editing/src/MultiLevelBuildTests.scala
@@ -87,7 +87,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       assert(res.isSuccess == false)
       // Prepend a "\n" to allow callsites to use "\n" to test for start of
       // line, even though the first line doesn't have a "\n" at the start
-      val err = "\n" + res.err
+      val err = "```\n" + res.err + "\n```"
       for (expected <- expectedSnippets) {
         assert(err.contains(expected))
       }
@@ -130,7 +130,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
 
     test("validEdits") - integrationTest { tester =>
       import tester._
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -143,7 +143,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, true, true, true)
 
       modifyFile(workspacePath / "foo/src/Example.scala", _.replace("!", "?"))
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>?")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>?")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -155,7 +155,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, false, false, false)
 
       modifyFile(workspacePath / "build.mill", _.replace("hello", "HELLO"))
-      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>0.8.2</p>?")
+      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>0.13.1</p>?")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -169,7 +169,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
         workspacePath / "mill-build/build.mill",
         _.replace("def scalatagsVersion = ", "def scalatagsVersion = \"changed-\" + ")
       )
-      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>changed-0.8.2</p>?")
+      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>changed-0.13.1</p>?")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -181,7 +181,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
 
       modifyFile(
         workspacePath / "mill-build/mill-build/build.mill",
-        _.replace("0.8.2", "0.12.0")
+        _.replace("0.13.1", "0.12.0")
       )
       runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>changed-0.12.0</p>?")
       checkWatchedFiles(
@@ -195,9 +195,9 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
 
       modifyFile(
         workspacePath / "mill-build/mill-build/build.mill",
-        _.replace("0.12.0", "0.8.2")
+        _.replace("0.12.0", "0.13.1")
       )
-      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>changed-0.8.2</p>?")
+      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>changed-0.13.1</p>?")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -211,7 +211,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
         workspacePath / "mill-build/build.mill",
         _.replace("def scalatagsVersion = \"changed-\" + ", "def scalatagsVersion = ")
       )
-      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>0.8.2</p>?")
+      runAssertSuccess(tester, "<h1>HELLO</h1><p>world</p><p>0.13.1</p>?")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -222,7 +222,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, true, true, false)
 
       modifyFile(workspacePath / "build.mill", _.replace("HELLO", "hello"))
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>?")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>?")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -233,7 +233,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, true, false, false)
 
       modifyFile(workspacePath / "foo/src/Example.scala", _.replace("?", "!"))
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -252,7 +252,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       def fixParseError(p: os.Path) =
         modifyFile(p, _.replace("extendx", "extends"))
 
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -300,7 +300,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, null, null, null)
 
       fixParseError(workspacePath / "build.mill")
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -319,7 +319,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       def fixCompileError(p: os.Path) =
         modifyFile(p, _.replace("import doesnt.exist", ""))
 
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -382,7 +382,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, null, true, false)
 
       fixCompileError(workspacePath / "build.mill")
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -407,7 +407,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       def fixRuntimeError(p: os.Path) =
         modifyFile(p, _.replaceFirst(Regex.quote(runErrorSnippet), "\\{"))
 
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
@@ -475,7 +475,7 @@ object MultiLevelBuildTests extends UtestIntegrationTestSuite {
       checkChangedClassloaders(tester, null, true, true, false)
 
       fixRuntimeError(workspacePath / "build.mill")
-      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      runAssertSuccess(tester, "<h1>hello</h1><p>world</p><p>0.13.1</p>!")
       checkWatchedFiles(
         tester,
         fooPaths(tester),
diff --git a/main/api/src/mill/api/AggWrapper.scala b/main/api/src/mill/api/AggWrapper.scala
index 06382846437..9be41fb579b 100644
--- a/main/api/src/mill/api/AggWrapper.scala
+++ b/main/api/src/mill/api/AggWrapper.scala
@@ -85,16 +85,15 @@ private[mill] sealed class AggWrapper(strictUniqueness: Boolean) {
         Mutable.newBuilder[V]
       }
 
-      private[this] val set0 = mutable.LinkedHashSet.empty[V]
+      private val set0 = mutable.LinkedHashSet.empty[V]
 
       def contains(v: V): Boolean = set0.contains(v)
       def coll: Mutable[V] = this
 
-      override def toIterable: Iterable[V] = set0.toIterable
+      override def toIterable: Iterable[V] = set0
       def append(v: V): AnyVal = {
         if (!contains(v)) {
-          set0.add(v)
-
+          return set0.add(v)
         } else if (strictUniqueness) {
           throw new Exception("Duplicated item inserted into OrderedSet: " + v)
         }
@@ -118,7 +117,9 @@ private[mill] sealed class AggWrapper(strictUniqueness: Boolean) {
 
       override def filter(f: V => Boolean): Mutable[V] = {
         val output = new Agg.Mutable[V]
-        for (i <- items) if (f(i)) output.append(i)
+        for (i <- items) if (f(i)) {
+          val _ = output.append(i)
+        }
         output
       }
 
@@ -148,7 +149,7 @@ private[mill] sealed class AggWrapper(strictUniqueness: Boolean) {
       def iterator: Iterator[V] = items
       override def hashCode(): Int = items.map(_.hashCode()).sum
       override def equals(other: Any): Boolean = other match {
-        case s: Agg[_] => items.sameElements(s.items)
+        case s: Agg[?] => items.sameElements(s.items)
         case _ => super.equals(other)
       }
       override def toString: String = items.mkString("Agg(", ", ", ")")
diff --git a/main/api/src/mill/api/ClassLoader.scala b/main/api/src/mill/api/ClassLoader.scala
index 6f2b5ec7f2b..5db97159d63 100644
--- a/main/api/src/mill/api/ClassLoader.scala
+++ b/main/api/src/mill/api/ClassLoader.scala
@@ -26,7 +26,7 @@ object ClassLoader {
       makeUrls(urls).toArray,
       refinePlatformParent(parent)
     ) {
-      override def findClass(name: String): Class[_] = {
+      override def findClass(name: String): Class[?] = {
         if (sharedPrefixes.exists(name.startsWith)) {
           logger.foreach(
             _.debug(s"About to load class [${name}] from shared classloader [${sharedLoader}]")
diff --git a/main/api/src/mill/api/Ctx.scala b/main/api/src/mill/api/Ctx.scala
index ca08069896b..59ad59d3d67 100644
--- a/main/api/src/mill/api/Ctx.scala
+++ b/main/api/src/mill/api/Ctx.scala
@@ -73,7 +73,7 @@ object Ctx {
   }
 
   trait Args {
-    def args: IndexedSeq[_]
+    def args: IndexedSeq[?]
   }
 
   /**
@@ -167,7 +167,7 @@ object Ctx {
  * implementation of a `Task`.
  */
 class Ctx(
-    val args: IndexedSeq[_],
+    val args: IndexedSeq[?],
     dest0: () => os.Path,
     val log: Logger,
     val home: os.Path,
@@ -185,7 +185,7 @@ class Ctx(
     with Ctx.Workspace {
 
   def this(
-      args: IndexedSeq[_],
+      args: IndexedSeq[?],
       dest0: () => os.Path,
       log: Logger,
       home: os.Path,
@@ -194,7 +194,7 @@ class Ctx(
       testReporter: TestReporter,
       workspace: os.Path
   ) = {
-    this(args, dest0, log, home, env, reporter, testReporter, workspace, i => ???, null)
+    this(args, dest0, log, home, env, reporter, testReporter, workspace, _ => ???, null)
   }
   def dest: os.Path = dest0()
   def arg[T](index: Int): T = {
diff --git a/main/api/src/mill/api/FixSizedCache.scala b/main/api/src/mill/api/FixSizedCache.scala
index 5d71874246b..0ba0f2a12e5 100644
--- a/main/api/src/mill/api/FixSizedCache.scala
+++ b/main/api/src/mill/api/FixSizedCache.scala
@@ -15,7 +15,7 @@ import java.util.concurrent.{ConcurrentHashMap, Semaphore}
 class FixSizedCache[T](perKeySize: Int) extends KeyedLockedCache[T] {
 
   // Cache Key -> (Semaphore, Array of cached elements)
-  private[this] val keyToCache: ConcurrentHashMap[Long, (Semaphore, Array[(Boolean, Option[T])])] =
+  private val keyToCache: ConcurrentHashMap[Long, (Semaphore, Array[(Boolean, Option[T])])] =
     new ConcurrentHashMap
 
   override def withCachedValue[V](key: Long)(f: => T)(f2: T => V): V = {
diff --git a/main/api/src/mill/api/JarOps.scala b/main/api/src/mill/api/JarOps.scala
index 9f2e0d2a737..540c706ca29 100644
--- a/main/api/src/mill/api/JarOps.scala
+++ b/main/api/src/mill/api/JarOps.scala
@@ -73,7 +73,7 @@ trait JarOps {
     os.remove.all(jar)
 
     val seen = mutable.Set.empty[os.RelPath]
-    seen.add(os.sub / "META-INF/MANIFEST.MF")
+    val _ = seen.add(os.sub / "META-INF/MANIFEST.MF")
 
     val jarStream = new JarOutputStream(
       new BufferedOutputStream(new FileOutputStream(jar.toIO)),
@@ -84,7 +84,7 @@ trait JarOps {
       assert(inputPaths.iterator.forall(os.exists(_)))
 
       if (includeDirs) {
-        seen.add(os.sub / "META-INF")
+        val _ = seen.add(os.sub / "META-INF")
         val entry = new JarEntry("META-INF/")
         entry.setTime(curTime)
         jarStream.putNextEntry(entry)
@@ -99,7 +99,7 @@ trait JarOps {
           else os.walk(p).map(sub => (sub, sub.subRelativeTo(p))).sorted
         if (includeDirs || os.isFile(file)) && !seen(mapping) && fileFilter(p, mapping)
       } {
-        seen.add(mapping)
+        val _ = seen.add(mapping)
         val name = mapping.toString() + (if (os.isDir(file)) "/" else "")
         val entry = new JarEntry(name)
         entry.setTime(mTime(file))
diff --git a/main/api/src/mill/api/JsonFormatters.scala b/main/api/src/mill/api/JsonFormatters.scala
index dda6a1c3cc1..bf1b448955f 100644
--- a/main/api/src/mill/api/JsonFormatters.scala
+++ b/main/api/src/mill/api/JsonFormatters.scala
@@ -62,7 +62,7 @@ trait JsonFormatters {
         )
     )
 
-  implicit def enumFormat[T <: java.lang.Enum[_]: ClassTag]: RW[T] =
+  implicit def enumFormat[T <: java.lang.Enum[?]: ClassTag]: RW[T] =
     upickle.default.readwriter[String].bimap(
       _.name(),
       (s: String) =>
diff --git a/main/api/src/mill/api/KeyedLockedCache.scala b/main/api/src/mill/api/KeyedLockedCache.scala
index 7a8fc21a92f..3ee62796f3c 100644
--- a/main/api/src/mill/api/KeyedLockedCache.scala
+++ b/main/api/src/mill/api/KeyedLockedCache.scala
@@ -11,7 +11,7 @@ trait KeyedLockedCache[T] {
 
 object KeyedLockedCache {
   class RandomBoundedCache[T](hotParallelism: Int, coldCacheSize: Int) extends KeyedLockedCache[T] {
-    private[this] val random = new scala.util.Random(313373)
+    private val random = new scala.util.Random(313373)
     val available = new java.util.concurrent.Semaphore(hotParallelism)
 
     // Awful asymptotic complexity, but our caches are tiny n < 10 so it doesn't matter
diff --git a/main/api/src/mill/api/PathRef.scala b/main/api/src/mill/api/PathRef.scala
index ad1ae5a44eb..483efa569c1 100644
--- a/main/api/src/mill/api/PathRef.scala
+++ b/main/api/src/mill/api/PathRef.scala
@@ -1,10 +1,13 @@
 package mill.api
 
+import scala.language.implicitConversions
+
 import java.nio.{file => jnio}
 import java.security.{DigestOutputStream, MessageDigest}
 import java.util.concurrent.ConcurrentHashMap
 import scala.util.{DynamicVariable, Using}
 import upickle.default.{ReadWriter => RW}
+import scala.annotation.nowarn
 
 /**
  * A wrapper around `os.Path` that calculates it's hashcode based
@@ -69,7 +72,7 @@ object PathRef {
           if (pathRef.sig != changedSig) {
             throw new PathRefValidationException(pathRef)
           }
-          map.put(mapKey(pathRef), pathRef)
+          val _ = map.put(mapKey(pathRef), pathRef)
       }
     }
     def clear(): Unit = map.clear()
@@ -197,6 +200,7 @@ object PathRef {
   )
 
   // scalafix:off; we want to hide the unapply method
+  @nowarn("msg=unused")
   private def unapply(pathRef: PathRef): Option[(os.Path, Boolean, Int, Revalidate)] = {
     Some((pathRef.path, pathRef.quick, pathRef.sig, pathRef.revalidate))
   }
diff --git a/main/api/src/mill/api/Result.scala b/main/api/src/mill/api/Result.scala
index ad7af1e051b..afe73a5c2d1 100644
--- a/main/api/src/mill/api/Result.scala
+++ b/main/api/src/mill/api/Result.scala
@@ -13,9 +13,10 @@ sealed trait Result[+T] {
   def flatMap[V](f: T => Result[V]): Result[V]
   def asSuccess: Option[Result.Success[T]] = None
   def asFailing: Option[Result.Failing[T]] = None
-  def getOrThrow: T = this match {
+  def getOrThrow: T = (this: @unchecked) match {
     case Result.Success(v) => v
-    case f: Result.Failing[_] => throw f
+    case f: Result.Failing[?] => throw f
+    // no cases for Skipped or Aborted?
   }
 }
 
@@ -95,10 +96,15 @@ object Result {
         current = current.head.getCause :: current
       }
       current.reverse
-        .flatMap(ex =>
-          Seq(ex.toString) ++
-            ex.getStackTrace.dropRight(outerStack.value.length).map("    " + _)
-        )
+        .flatMap { ex =>
+          val elements = ex.getStackTrace.dropRight(outerStack.value.length)
+          val formatted =
+            // for some reason .map without the explicit ArrayOps conversion doesn't work,
+            // and results in `Result[String]` instead of `Array[String]`
+            new scala.collection.ArrayOps(elements).map("    " + _)
+          Seq(ex.toString) ++ formatted
+
+        }
         .mkString("\n")
     }
   }
diff --git a/main/api/src/mill/api/Retry.scala b/main/api/src/mill/api/Retry.scala
index 2398d4e87e7..ca35b0537f7 100644
--- a/main/api/src/mill/api/Retry.scala
+++ b/main/api/src/mill/api/Retry.scala
@@ -38,9 +38,9 @@ case class Retry(
         if (timeoutMillis == -1) t(retryCount)
         else {
           val result = Promise[T]
-          val thread = new Thread(() => {
+          val thread = new Thread({ () =>
             result.complete(scala.util.Try(t(retryCount)))
-          })
+          }: Runnable)
           thread.start()
           Await.result(result.future, Duration.apply(timeoutMillis, TimeUnit.MILLISECONDS))
         }
diff --git a/main/api/src/mill/api/SystemStreams.scala b/main/api/src/mill/api/SystemStreams.scala
index e42b34d80ed..3912eb57042 100644
--- a/main/api/src/mill/api/SystemStreams.scala
+++ b/main/api/src/mill/api/SystemStreams.scala
@@ -132,9 +132,9 @@ object SystemStreams {
   def setTopLevelSystemStreamProxy(): Unit = {
     // Make sure to initialize `Console` to cache references to the original
     // `System.{in,out,err}` streams before we redirect them
-    Console.out
-    Console.err
-    Console.in
+    val _ = Console.out
+    val _ = Console.err
+    val _ = Console.in
     System.setIn(ThreadLocalStreams.In)
     System.setOut(ThreadLocalStreams.Out)
     System.setErr(ThreadLocalStreams.Err)
diff --git a/main/codesig/package.mill b/main/codesig/package.mill
index 51c622e5054..7e0120def83 100644
--- a/main/codesig/package.mill
+++ b/main/codesig/package.mill
@@ -47,7 +47,8 @@ object `package` extends RootModule with build.MillPublishScalaModule {
           build.Deps.mainargs,
           build.Deps.requests,
           build.Deps.osLib,
-          build.Deps.upickle
+          build.Deps.upickle,
+          build.Deps.sourcecode
         )
       }
     }
diff --git a/main/codesig/src/JvmModel.scala b/main/codesig/src/JvmModel.scala
index 00c36c8fd31..e63eeffa937 100644
--- a/main/codesig/src/JvmModel.scala
+++ b/main/codesig/src/JvmModel.scala
@@ -139,7 +139,7 @@ object JvmModel {
 
     sealed class Prim(val pretty: String) extends JType
 
-    object Prim extends {
+    object Prim {
       def read(s: String): Prim = all(s(0))
 
       val all: Map[Char, Prim] = Map(
diff --git a/main/codesig/src/ResolvedCalls.scala b/main/codesig/src/ResolvedCalls.scala
index 7b2fe32a26d..6bb5b5698f7 100644
--- a/main/codesig/src/ResolvedCalls.scala
+++ b/main/codesig/src/ResolvedCalls.scala
@@ -113,7 +113,9 @@ object ResolvedCalls {
       val externalSamDefiners = externalSummary
         .directMethods
         .map { case (k, v) => (k, v.collect { case (sig, true) => sig }) }
-        .collect { case (k, Seq(v)) => (k, v) }
+        .collect { case (k, Seq(v)) =>
+          (k, v)
+        } // Scala 3.5.0-RC6 - can not infer MethodSig here
 
       val allSamDefiners = localSamDefiners ++ externalSamDefiners
 
diff --git a/main/codesig/src/SpanningForest.scala b/main/codesig/src/SpanningForest.scala
index 115d60b3554..dd870bd4827 100644
--- a/main/codesig/src/SpanningForest.scala
+++ b/main/codesig/src/SpanningForest.scala
@@ -36,7 +36,11 @@ object SpanningForest {
       .groupMap(_._1)(_._2)
 
     ResolvedCalls.breadthFirst(rootChangedNodeIndices) { index =>
-      val nextIndices = downstreamGraphEdges.getOrElse(index, Array())
+      val nextIndices =
+        downstreamGraphEdges.getOrElse(
+          index,
+          Array[Int]()
+        ) // needed to add explicit type for Scala 3.5.0-RC6
       // We build up the spanningForest during a normal breadth first search,
       // using the `nodeMapping` to quickly find an vertice's tree node so we
       // can add children to it. We need to duplicate the `seen.contains` logic
diff --git a/main/codesig/test/cases/callgraph/basic/17-scala-lambda/src/Hello.scala b/main/codesig/test/cases/callgraph/basic/17-scala-lambda/src/Hello.scala
index 45fdc0c8195..d9c7a6141ff 100644
--- a/main/codesig/test/cases/callgraph/basic/17-scala-lambda/src/Hello.scala
+++ b/main/codesig/test/cases/callgraph/basic/17-scala-lambda/src/Hello.scala
@@ -1,9 +1,14 @@
 package hello
 
 object Hello {
+
+  trait MyFunction0[T] {
+    def apply(): T
+  }
+
   def main(): Int = {
 
-    val foo = () => used()
+    val foo: MyFunction0[Int] = () => used()
     foo()
   }
   def used(): Int = 2
diff --git a/main/codesig/test/cases/callgraph/complicated/13-iterator-inherit-external-filter-scala/src/Hello.scala b/main/codesig/test/cases/callgraph/complicated/13-iterator-inherit-external-filter-scala/src/Hello.scala
index 7096870a717..6861bc5ecf2 100644
--- a/main/codesig/test/cases/callgraph/complicated/13-iterator-inherit-external-filter-scala/src/Hello.scala
+++ b/main/codesig/test/cases/callgraph/complicated/13-iterator-inherit-external-filter-scala/src/Hello.scala
@@ -26,10 +26,11 @@ object Hello {
     private[this] var hdDefined: Boolean = false
 
     def hasNext: Boolean = hdDefined || {
-      do {
+      while ({
         if (!parent.hasNext) return false
         hd = parent.next()
-      } while (!pred(hd))
+        !pred(hd)
+      }) {}
       hdDefined = true
       true
     }
diff --git a/main/codesig/test/cases/callgraph/complicated/6-classes-misc-scala/src/Hello.scala b/main/codesig/test/cases/callgraph/complicated/6-classes-misc-scala/src/Hello.scala
index 39896097bae..a724d7d6d3b 100644
--- a/main/codesig/test/cases/callgraph/complicated/6-classes-misc-scala/src/Hello.scala
+++ b/main/codesig/test/cases/callgraph/complicated/6-classes-misc-scala/src/Hello.scala
@@ -32,7 +32,7 @@ class DoubleDetMatrix(aa: Float, ab: Float, ba: Float, bb: Float)
 }
 
 class LinkedList {
-  def push(i: Int) {
+  def push(i: Int): Unit = {
     val n = new Inner(i, head)
     head = n
   }
diff --git a/main/codesig/test/cases/callgraph/complicated/8-linked-list-scala/src/Hello.scala b/main/codesig/test/cases/callgraph/complicated/8-linked-list-scala/src/Hello.scala
index 061c4c14aeb..5235986b920 100644
--- a/main/codesig/test/cases/callgraph/complicated/8-linked-list-scala/src/Hello.scala
+++ b/main/codesig/test/cases/callgraph/complicated/8-linked-list-scala/src/Hello.scala
@@ -9,7 +9,7 @@ object Hello {
     def head: A
     def tail: TestList[A]
 
-    def foreach[U](f: A => U) {
+    def foreach[U](f: A => U): Unit = {
       var these = this
       while (!these.isEmpty) {
         f(these.head)
@@ -21,7 +21,7 @@ object Hello {
   object TestNil extends TestList[Nothing] {
     def isEmpty = true
     def head = throw new Exception()
-    def tail = throw new Exception()
+    override def tail: Nothing = throw new Exception()
   }
 
   class TestCons[B](val head: B, val tl: TestList[B]) extends TestList[B] {
diff --git a/main/codesig/test/cases/callgraph/realistic/5-parser/src/Hello.scala b/main/codesig/test/cases/callgraph/realistic/5-parser/src/Hello.scala
index 1fb9a5a8a10..52df0ce57f6 100644
--- a/main/codesig/test/cases/callgraph/realistic/5-parser/src/Hello.scala
+++ b/main/codesig/test/cases/callgraph/realistic/5-parser/src/Hello.scala
@@ -6,15 +6,15 @@ class Word(s: String) extends Phrase
 class Pair(lhs: Phrase, rhs: Phrase) extends Phrase
 
 object Parser {
-  def prefix[_: P] = P("hello" | "goodbye").!.map(new Word(_))
+  def prefix[$: P] = P("hello" | "goodbye").!.map(new Word(_))
 
-  def suffix[_: P] = P("world" | "seattle").!.map(new Word(_))
+  def suffix[$: P] = P("world" | "seattle").!.map(new Word(_))
 
-  def ws[_: P] = P(" ".rep(1))
+  def ws[$: P] = P(" ".rep(1))
 
-  def parened[_: P] = P("(" ~ parser ~ ")")
+  def parened[$: P] = P("(" ~ parser ~ ")")
 
-  def parser[_: P]: P[Phrase] = P((parened | prefix) ~ ws ~ (parened | suffix)).map {
+  def parser[$: P]: P[Phrase] = P((parened | prefix) ~ ws ~ (parened | suffix)).map {
     case (lhs, rhs) => new Pair(lhs, rhs)
   }
 }
diff --git a/main/define/test/src/mill/define/BasePathTests.scala b/main/define/test/src/mill/define/BasePathTests.scala
index dce543ca02b..55901cb9778 100644
--- a/main/define/test/src/mill/define/BasePathTests.scala
+++ b/main/define/test/src/mill/define/BasePathTests.scala
@@ -5,6 +5,17 @@ import mill.testkit.TestBaseModule
 import utest._
 
 object BasePathTests extends TestSuite {
+
+  object overriddenBasePath extends TestBaseModule {
+    override def millSourcePath = os.pwd / "overriddenBasePathRootValue"
+    object nested extends Module {
+      override def millSourcePath = super.millSourcePath / "overriddenBasePathNested"
+      object nested extends Module {
+        override def millSourcePath = super.millSourcePath / "overriddenBasePathDoubleNested"
+      }
+    }
+  }
+
   val testGraphs = new TestGraphs
   val tests = Tests {
     def checkMillSourcePath[T <: Module](m: T)(f: T => Module, segments: String*): Unit = {
@@ -54,15 +65,6 @@ object BasePathTests extends TestSuite {
       checkMillSourcePath(TestGraphs.nestedCrosses)(_.cross("210").cross2("js"), "cross", "cross2")
     }
     test("overridden") {
-      object overriddenBasePath extends TestBaseModule {
-        override def millSourcePath = os.pwd / "overriddenBasePathRootValue"
-        object nested extends Module {
-          override def millSourcePath = super.millSourcePath / "overriddenBasePathNested"
-          object nested extends Module {
-            override def millSourcePath = super.millSourcePath / "overriddenBasePathDoubleNested"
-          }
-        }
-      }
       assert(
         overriddenBasePath.millSourcePath == os.pwd / "overriddenBasePathRootValue",
         overriddenBasePath.nested.millSourcePath == os.pwd / "overriddenBasePathRootValue/nested/overriddenBasePathNested",
diff --git a/main/eval/src/mill/eval/EvaluatorCore.scala b/main/eval/src/mill/eval/EvaluatorCore.scala
index 932d73092bd..9e7af3684bd 100644
--- a/main/eval/src/mill/eval/EvaluatorCore.scala
+++ b/main/eval/src/mill/eval/EvaluatorCore.scala
@@ -265,10 +265,10 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
         c.getInterfaces.iterator.flatMap(resolveTransitiveParents)
     }
 
-    val classToTransitiveClasses = sortedGroups
+    val classToTransitiveClasses: Map[Class[?], IndexedSeq[Class[?]]] = sortedGroups
       .values()
       .flatten
-      .collect { case namedTask: NamedTask[_] => namedTask.ctx.enclosingCls }
+      .collect { case namedTask: NamedTask[?] => namedTask.ctx.enclosingCls }
       .map(cls => cls -> resolveTransitiveParents(cls).toVector)
       .toMap
 
@@ -277,22 +277,23 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
       .flatMap(_._2)
       .toSet
 
-    val allTransitiveClassMethods = allTransitiveClasses
-      .map { cls =>
-        val cMangledName = cls.getName.replace('.', '$')
-        cls -> cls.getDeclaredMethods
-          .flatMap { m =>
-            Seq(
-              m.getName -> m,
-              // Handle scenarios where private method names get mangled when they are
-              // not really JVM-private due to being accessed by Scala nested objects
-              // or classes https://github.com/scala/bug/issues/9306
-              m.getName.stripPrefix(cMangledName + "$$") -> m,
-              m.getName.stripPrefix(cMangledName + "$") -> m
-            )
-          }.toMap
-      }
-      .toMap
+    val allTransitiveClassMethods: Map[Class[?], Map[String, java.lang.reflect.Method]] =
+      allTransitiveClasses
+        .map { cls =>
+          val cMangledName = cls.getName.replace('.', '$')
+          cls -> cls.getDeclaredMethods
+            .flatMap { m =>
+              Seq(
+                m.getName -> m,
+                // Handle scenarios where private method names get mangled when they are
+                // not really JVM-private due to being accessed by Scala nested objects
+                // or classes https://github.com/scala/bug/issues/9306
+                m.getName.stripPrefix(cMangledName + "$$") -> m,
+                m.getName.stripPrefix(cMangledName + "$") -> m
+              )
+            }.toMap
+        }
+        .toMap
 
     (classToTransitiveClasses, allTransitiveClassMethods)
   }
diff --git a/main/eval/src/mill/eval/GroupEvaluator.scala b/main/eval/src/mill/eval/GroupEvaluator.scala
index 676505ecf98..a5db8328364 100644
--- a/main/eval/src/mill/eval/GroupEvaluator.scala
+++ b/main/eval/src/mill/eval/GroupEvaluator.scala
@@ -383,7 +383,7 @@ private[mill] trait GroupEvaluator {
       .task
       .writerOpt
       .map { w =>
-        upickle.default.writeJs(v.value)(w.asInstanceOf[upickle.default.Writer[Any]])
+        upickle.default.writeJs(v.value)(using w.asInstanceOf[upickle.default.Writer[Any]])
       }
       .orElse {
         labelled.task.asWorker.map { w =>
@@ -438,7 +438,7 @@ private[mill] trait GroupEvaluator {
         _ <- Option.when(cached.inputsHash == inputsHash)(())
         reader <- labelled.task.readWriterOpt
         parsed <-
-          try Some(upickle.default.read(cached.value)(reader))
+          try Some(upickle.default.read(cached.value)(using reader))
           catch {
             case e: PathRef.PathRefValidationException =>
               logger.debug(
diff --git a/main/eval/test/src/mill/eval/EvaluationTests.scala b/main/eval/test/src/mill/eval/EvaluationTests.scala
index ea0462c123f..021d5790663 100644
--- a/main/eval/test/src/mill/eval/EvaluationTests.scala
+++ b/main/eval/test/src/mill/eval/EvaluationTests.scala
@@ -1,6 +1,6 @@
 package mill.eval
 
-import mill.util.TestUtil.{Test, test}
+import mill.util.TestUtil.Test
 import mill.define.{TargetImpl, Task}
 import mill.T
 import mill.util.{TestGraphs, TestUtil}
@@ -61,9 +61,10 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
     object graphs extends TestGraphs()
     import graphs._
     import TestGraphs._
-    utest.test("evaluateSingle") {
+    import utest._
+    test("evaluateSingle") {
 
-      utest.test("singleton") {
+      test("singleton") {
         import singleton._
         val check = new Checker(singleton)
         // First time the target is evaluated
@@ -73,7 +74,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         // After incrementing the counter, it forces re-evaluation
         check(single, expValue = 1, expEvaled = Agg(single))
       }
-      utest.test("backtickIdentifiers") {
+      test("backtickIdentifiers") {
         import graphs.bactickIdentifiers._
         val check = new Checker(bactickIdentifiers)
 
@@ -85,7 +86,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         `up-target`.counter += 1
         check(`a-down-target`, expValue = 2, expEvaled = Agg(`up-target`, `a-down-target`))
       }
-      utest.test("pair") {
+      test("pair") {
         import pair._
         val check = new Checker(pair)
         check(down, expValue = 0, expEvaled = Agg(up, down))
@@ -96,7 +97,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         up.counter += 1
         check(down, expValue = 2, expEvaled = Agg(up, down))
       }
-      utest.test("anonTriple") {
+      test("anonTriple") {
         import anonTriple._
         val check = new Checker(anonTriple)
         val middle = down.inputs(0)
@@ -112,7 +113,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
 
         check(down, expValue = 3, expEvaled = Agg(middle, down))
       }
-      utest.test("diamond") {
+      test("diamond") {
         import diamond._
         val check = new Checker(diamond)
         check(down, expValue = 0, expEvaled = Agg(up, left, right, down))
@@ -130,7 +131,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         right.counter += 1
         check(down, expValue = 5, expEvaled = Agg(right, down))
       }
-      utest.test("anonDiamond") {
+      test("anonDiamond") {
         import anonDiamond._
         val check = new Checker(anonDiamond)
         val left = down.inputs(0).asInstanceOf[TestUtil.Test]
@@ -151,7 +152,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         check(down, expValue = 5, expEvaled = Agg(left, right, down))
       }
 
-      utest.test("bigSingleTerminal") {
+      test("bigSingleTerminal") {
         import bigSingleTerminal._
         val check = new Checker(bigSingleTerminal)
 
@@ -170,8 +171,8 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
       }
     }
 
-    utest.test("evaluateMixed") {
-      utest.test("separateGroups") {
+    test("evaluateMixed") {
+      test("separateGroups") {
         // Make sure that `left` and `right` are able to recompute separately,
         // even though one depends on the other
 
@@ -189,7 +190,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         assert(filtered3 == Agg(change, right))
 
       }
-      utest.test("triangleTask") {
+      test("triangleTask") {
 
         import triangleTask._
         val checker = new Checker(triangleTask)
@@ -197,7 +198,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         checker(left, 1, Agg(), extraEvaled = -1)
 
       }
-      utest.test("multiTerminalGroup") {
+      test("multiTerminalGroup") {
         import multiTerminalGroup._
 
         val checker = new Checker(multiTerminalGroup)
@@ -205,7 +206,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         checker(left, 1, Agg(left), extraEvaled = -1)
       }
 
-      utest.test("multiTerminalBoundary") {
+      test("multiTerminalBoundary") {
 
         import multiTerminalBoundary._
 
@@ -214,7 +215,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         checker(task2, 4, Agg(), extraEvaled = -1, secondRunNoOp = false)
       }
 
-      utest.test("overrideSuperTask") {
+      test("overrideSuperTask") {
         // Make sure you can override targets, call their supers, and have the
         // overridden target be allocated a spot within the overridden/ folder of
         // the main publicly-available target
@@ -234,7 +235,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
           !overridden.contains("object")
         )
       }
-      utest.test("overrideSuperCommand") {
+      test("overrideSuperCommand") {
         // Make sure you can override commands, call their supers, and have the
         // overridden command be allocated a spot within the super/ folder of
         // the main publicly-available command
@@ -261,7 +262,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
           !overridden.contains("object1")
         )
       }
-      utest.test("nullTasks") {
+      test("nullTasks") {
         import nullTasks._
         val checker = new Checker(nullTasks)
         checker(nullTarget1, null, Agg(nullTarget1), extraEvaled = -1)
@@ -288,7 +289,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         checker(nc4, null, Agg(nc4), extraEvaled = -1, secondRunNoOp = false)
       }
 
-      utest.test("tasksAreUncached") {
+      test("tasksAreUncached") {
         // Make sure the tasks `left` and `middle` re-compute every time, while
         // the target `right` does not
         //
@@ -301,7 +302,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
           var leftCount = 0
           var rightCount = 0
           var middleCount = 0
-          def up = Task { test.anon() }
+          def up = Task { TestUtil.test.anon() }
           def left = Task.Anon { leftCount += 1; up() + 1 }
           def middle = Task.Anon { middleCount += 1; 100 }
           def right = Task { rightCount += 1; 10000 }
@@ -352,7 +353,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
         assert(leftCount == 4, middleCount == 4, rightCount == 1)
       }
     }
-    utest.test("stackableOverrides") {
+    test("stackableOverrides") {
       // Make sure you can override commands, call their supers, and have the
       // overridden command be allocated a spot within the super/ folder of
       // the main publicly-available command
@@ -376,7 +377,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
       )
       assert(os.read(checker.evaluator.outPath / "m/f.json").contains(" 6,"))
     }
-    utest.test("stackableOverrides2") {
+    test("stackableOverrides2") {
       // When the supers have the same name, qualify them until they are distinct
       import StackableOverrides2._
 
@@ -398,7 +399,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
       )
       assert(os.read(checker.evaluator.outPath / "m/f.json").contains(" 6,"))
     }
-    utest.test("stackableOverrides3") {
+    test("stackableOverrides3") {
       // When the supers have the same name, qualify them until they are distinct
       import StackableOverrides3._
 
@@ -420,7 +421,7 @@ class EvaluationTests(threadCount: Option[Int]) extends TestSuite {
       )
       assert(os.read(checker.evaluator.outPath / "m/f.json").contains(" 6,"))
     }
-    utest.test("privateTasksInMixedTraits") {
+    test("privateTasksInMixedTraits") {
       // Make sure we can have private cached targets in different trait with the same name,
       // and caching still works when these traits are mixed together
       import PrivateTasksInMixedTraits._
diff --git a/main/init/src/mill/init/InitModule.scala b/main/init/src/mill/init/InitModule.scala
index 76b05442767..87bfcd41a04 100644
--- a/main/init/src/mill/init/InitModule.scala
+++ b/main/init/src/mill/init/InitModule.scala
@@ -57,7 +57,7 @@ trait InitModule extends Module {
             val extractedPath = T.dest / extractedDirName
             val conflicting = for {
               p <- os.walk(extractedPath)
-              val rel = p.relativeTo(extractedPath)
+              rel = p.relativeTo(extractedPath)
               if os.exists(T.workspace / rel)
             } yield rel
 
@@ -97,7 +97,8 @@ trait InitModule extends Module {
   private def usingExamples[T](fun: Seq[(ExampleId, ExampleUrl)] => T): Try[T] =
     Using(getClass.getClassLoader.getResourceAsStream("exampleList.txt")) { exampleList =>
       val reader = upickle.default.reader[Seq[(ExampleId, ExampleUrl)]]
-      val exampleNames: Seq[(ExampleId, ExampleUrl)] = upickle.default.read(exampleList)(reader)
+      val exampleNames: Seq[(ExampleId, ExampleUrl)] =
+        upickle.default.read(exampleList)(using reader)
       fun(exampleNames)
     }
 }
diff --git a/main/package.mill b/main/package.mill
index 1ef11936329..083d84bce05 100644
--- a/main/package.mill
+++ b/main/package.mill
@@ -5,6 +5,7 @@ import mill.scalalib._
 import mill.contrib.buildinfo.BuildInfo
 import mill.T
 import mill.define.Cross
+import mill.scalalib.api.ZincWorkerUtil
 
 object `package` extends RootModule with build.MillStableScalaModule with BuildInfo {
 
@@ -19,12 +20,19 @@ object `package` extends RootModule with build.MillStableScalaModule with BuildI
     ivy"guru.nidi:graphviz-java-min-deps:0.18.1"
   )
 
-  def compileIvyDeps = Agg(build.Deps.scalaReflect(scalaVersion()))
+  def compileIvyDeps = T {
+    if (ZincWorkerUtil.isScala3(scalaVersion())) Agg.empty else Agg(build.Deps.scalaReflect(scalaVersion()))
+  }
 
   def buildInfoPackageName = "mill.main"
 
   def buildInfoMembers = Seq(
     BuildInfo.Value("scalaVersion", scalaVersion(), "Scala version used to compile mill core."),
+    BuildInfo.Value(
+      "workerScalaVersion213",
+      build.Deps.scala2Version,
+      "Scala 2.13 version used by some workers."
+    ),
     BuildInfo.Value(
       "workerScalaVersion212",
       build.Deps.workerScalaVersion212,
@@ -97,9 +105,15 @@ object `package` extends RootModule with build.MillStableScalaModule with BuildI
 
   object define extends build.MillStableScalaModule {
     def moduleDeps = Seq(api, util)
-    def compileIvyDeps = Agg(build.Deps.scalaReflect(scalaVersion()))
+    def compileIvyDeps = T {
+      if (ZincWorkerUtil.isScala3(scalaVersion())) Agg(build.Deps.scalaCompiler(scalaVersion()))
+      else Agg(build.Deps.scalaReflect(scalaVersion()))
+    }
     def ivyDeps = Agg(
       build.Deps.millModuledefs,
+      // TODO: somewhere sourcecode is included transitively,
+      // but we need the latest version to bring the macro improvements.
+      build.Deps.sourcecode,
       // Necessary so we can share the JNA classes throughout the build process
       build.Deps.jna,
       build.Deps.jnaPlatform,
diff --git a/main/resolve/src/mill/resolve/ExpandBraces.scala b/main/resolve/src/mill/resolve/ExpandBraces.scala
index fe68892a749..b0d7dc4ecbb 100644
--- a/main/resolve/src/mill/resolve/ExpandBraces.scala
+++ b/main/resolve/src/mill/resolve/ExpandBraces.scala
@@ -30,7 +30,7 @@ private object ExpandBraces {
   }
 
   def expandBraces(selectorString: String): Either[String, Seq[String]] = {
-    parse(selectorString, parser(_)) match {
+    parse(selectorString, parser(using _)) match {
       case f: Parsed.Failure => Left(s"Parsing exception ${f.msg}")
       case Parsed.Success(fragmentLists, _) =>
         Right(expandRec(fragmentLists.toList).map(_.mkString))
diff --git a/main/resolve/src/mill/resolve/ParseArgs.scala b/main/resolve/src/mill/resolve/ParseArgs.scala
index 36d6a8545b3..ae32b9089bf 100644
--- a/main/resolve/src/mill/resolve/ParseArgs.scala
+++ b/main/resolve/src/mill/resolve/ParseArgs.scala
@@ -88,7 +88,7 @@ object ParseArgs {
 
   def extractSegments(selectorString: String)
       : Either[String, (Option[Segments], Option[Segments])] =
-    parse(selectorString, selector(_)) match {
+    parse(selectorString, selector(using _)) match {
       case f: Parsed.Failure => Left(s"Parsing exception ${f.msg}")
       case Parsed.Success(selector, _) => Right(selector)
     }
diff --git a/main/resolve/src/mill/resolve/ResolveNotFoundHandler.scala b/main/resolve/src/mill/resolve/ResolveNotFoundHandler.scala
index 792cb920228..7b6551ed1fa 100644
--- a/main/resolve/src/mill/resolve/ResolveNotFoundHandler.scala
+++ b/main/resolve/src/mill/resolve/ResolveNotFoundHandler.scala
@@ -42,7 +42,7 @@ private object ResolveNotFoundHandler {
     val search = revSelectorsSoFar.render
 
     val lastSearchOpt = for {
-      Segment.Label(s) <- Option(lastSegment)
+      case Segment.Label(s) <- Option(lastSegment)
       if s != "_" && s != "__"
       possibility <- findMostSimilar(s, allPossibleNames)
     } yield "__." + possibility
@@ -71,13 +71,13 @@ private object ResolveNotFoundHandler {
   }
 
   def errorMsgLabel(
-      given: String,
+      `given`: String,
       possibleMembers: Set[String],
       prefixSegments: Segments,
       fullSegments: Segments,
       allPossibleNames: Set[String]
   ): String = {
-    val suggestion = findMostSimilar(given, possibleMembers) match {
+    val suggestion = findMostSimilar(`given`, possibleMembers) match {
       case None => hintListLabel(prefixSegments, fullSegments.value.last, allPossibleNames)
       case Some(similar) =>
         " Did you mean " +
diff --git a/main/server/src/mill/main/server/Server.scala b/main/server/src/mill/main/server/Server.scala
index 0852c4afef3..9b24dab9d0d 100644
--- a/main/server/src/mill/main/server/Server.scala
+++ b/main/server/src/mill/main/server/Server.scala
@@ -56,7 +56,8 @@ abstract class Server[T](
                   serverLog("handling run")
                   try handleRun(sock, initialSystemProperties)
                   catch {
-                    case e: Throwable => serverLog(e + "\n" + e.getStackTrace.mkString("\n"))
+                    case e: Throwable =>
+                      serverLog(e.toString + "\n" + e.getStackTrace.mkString("\n"))
                   } finally sock.close();
                   true
               }
diff --git a/main/src/mill/main/MainModule.scala b/main/src/mill/main/MainModule.scala
index df6ddd5a239..1771b96608b 100644
--- a/main/src/mill/main/MainModule.scala
+++ b/main/src/mill/main/MainModule.scala
@@ -438,7 +438,7 @@ trait MainModule extends BaseModule0 {
           for {
             workerSegments <- evaluator.workerCache.keys.toList
             if allSegments.exists(workerSegments.startsWith)
-            (_, Val(closeable: AutoCloseable)) <-
+            case (_, Val(closeable: AutoCloseable)) <-
               evaluator.mutableWorkerCache.remove(workerSegments)
           } {
             closeable.close()
@@ -481,7 +481,7 @@ trait MainModule extends BaseModule0 {
    */
   def shutdown(): Command[Unit] = Task.Command(exclusive = true) {
     Target.log.info("Shutting down Mill server...")
-    Target.ctx.systemExit(0)
+    Target.ctx().systemExit(0)
     ()
   }
 
diff --git a/main/src/mill/main/TokenReaders.scala b/main/src/mill/main/TokenReaders.scala
index 60c1b03e5d0..44374818aba 100644
--- a/main/src/mill/main/TokenReaders.scala
+++ b/main/src/mill/main/TokenReaders.scala
@@ -69,4 +69,5 @@ trait TokenReaders0 {
     case t: TokensReader.Leftover[_, _] => new LeftoverTaskTokenReader[T](t)
   }
 
+  def given = () // dummy for scala 2/3 compat
 }
diff --git a/main/util/src/mill/util/PrefixLogger.scala b/main/util/src/mill/util/PrefixLogger.scala
index 7ee393516a9..2718177b53b 100644
--- a/main/util/src/mill/util/PrefixLogger.scala
+++ b/main/util/src/mill/util/PrefixLogger.scala
@@ -67,11 +67,11 @@ class PrefixLogger(
 
   override def info(s: String): Unit = {
     reportKey(logPrefixKey)
-    logger0.info(infoColor(linePrefix) + s)
+    logger0.info("" + infoColor(linePrefix) + s)
   }
   override def error(s: String): Unit = {
     reportKey(logPrefixKey)
-    logger0.error(infoColor(linePrefix) + s)
+    logger0.error("" + infoColor(linePrefix) + s)
   }
   override def ticker(s: String): Unit = setPromptDetail(logPrefixKey, s)
   override def setPromptDetail(key: Seq[String], s: String): Unit = logger0.setPromptDetail(key, s)
@@ -90,7 +90,7 @@ class PrefixLogger(
 
   override def debug(s: String): Unit = {
     if (debugEnabled) reportKey(logPrefixKey)
-    logger0.debug(infoColor(linePrefix) + s)
+    logger0.debug("" + infoColor(linePrefix) + s)
   }
   override def debugEnabled: Boolean = logger0.debugEnabled
 
diff --git a/scalajslib/src/mill/scalajslib/ScalaJSModule.scala b/scalajslib/src/mill/scalajslib/ScalaJSModule.scala
index 1d88914ded0..10b412d1741 100644
--- a/scalajslib/src/mill/scalajslib/ScalaJSModule.scala
+++ b/scalajslib/src/mill/scalajslib/ScalaJSModule.scala
@@ -76,7 +76,7 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
 
   def scalaJSLinkerClasspath: T[Loose.Agg[PathRef]] = Task {
     val commonDeps = Seq(
-      ivy"org.scala-js::scalajs-sbt-test-adapter:${scalaJSVersion()}"
+      ivy"org.scala-js:scalajs-sbt-test-adapter_2.13:${scalaJSVersion()}"
     )
     val scalajsImportMapDeps = scalaJSVersion() match {
       case s"1.$n.$_" if n.toIntOption.exists(_ >= 16) && scalaJSImportMap().nonEmpty =>
@@ -92,7 +92,7 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
         )
       case "1" =>
         Seq(
-          ivy"org.scala-js::scalajs-linker:${scalaJSVersion()}"
+          ivy"org.scala-js:scalajs-linker_2.13:${scalaJSVersion()}"
         ) ++ scalaJSJsEnvIvyDeps()
     }
     // we need to use the scala-library of the currently running mill
diff --git a/scalajslib/test/src/mill/scalajslib/CompileLinkTests.scala b/scalajslib/test/src/mill/scalajslib/CompileLinkTests.scala
index efd9e0ac40b..43822fbe870 100644
--- a/scalajslib/test/src/mill/scalajslib/CompileLinkTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/CompileLinkTests.scala
@@ -44,7 +44,7 @@ object CompileLinkTests extends TestSuite {
       )
 
       object `test-utest` extends ScalaJSTests with TestModule.Utest {
-        override def sources = Task.Sources { millSourcePath / "src/utest" }
+        override def sources = Task.Sources { this.millSourcePath / "src/utest" }
         val utestVersion = if (ZincWorkerUtil.isScala3(crossScalaVersion)) "0.7.7" else "0.7.5"
         override def ivyDeps = Agg(
           ivy"com.lihaoyi::utest::$utestVersion"
@@ -52,7 +52,7 @@ object CompileLinkTests extends TestSuite {
       }
 
       object `test-scalatest` extends ScalaJSTests with TestModule.ScalaTest {
-        override def sources = Task.Sources { millSourcePath / "src/scalatest" }
+        override def sources = Task.Sources { this.millSourcePath / "src/scalatest" }
         override def ivyDeps = Agg(
           ivy"org.scalatest::scalatest::3.1.2"
         )
@@ -68,7 +68,10 @@ object CompileLinkTests extends TestSuite {
       object test extends ScalaJSTests with TestModule.Utest
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "hello-js-world"
diff --git a/scalajslib/test/src/mill/scalajslib/EsModuleRemapTests.scala b/scalajslib/test/src/mill/scalajslib/EsModuleRemapTests.scala
index 025fe010679..488c051082e 100644
--- a/scalajslib/test/src/mill/scalajslib/EsModuleRemapTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/EsModuleRemapTests.scala
@@ -25,7 +25,10 @@ object EsModuleRemapTests extends TestSuite {
       ESModuleImportMapping.Prefix("@stdlib/linspace", remapTo)
     )
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   object OldJsModule extends TestBaseModule with ScalaJSModule {
@@ -38,7 +41,10 @@ object EsModuleRemapTests extends TestSuite {
       ESModuleImportMapping.Prefix("@stdlib/linspace", remapTo)
     )
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "esModuleRemap"
diff --git a/scalajslib/test/src/mill/scalajslib/FullOptESModuleTests.scala b/scalajslib/test/src/mill/scalajslib/FullOptESModuleTests.scala
index 9da8030876f..417b8a34c34 100644
--- a/scalajslib/test/src/mill/scalajslib/FullOptESModuleTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/FullOptESModuleTests.scala
@@ -16,7 +16,10 @@ object FullOptESModuleTests extends TestSuite {
       override def moduleKind = ModuleKind.ESModule
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "hello-js-world"
diff --git a/scalajslib/test/src/mill/scalajslib/MultiModuleTests.scala b/scalajslib/test/src/mill/scalajslib/MultiModuleTests.scala
index 7df52a447d1..4ca8c7d6543 100644
--- a/scalajslib/test/src/mill/scalajslib/MultiModuleTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/MultiModuleTests.scala
@@ -29,7 +29,10 @@ object MultiModuleTests extends TestSuite {
       override def millSourcePath = MultiModule.millSourcePath / "shared"
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val evaluator = UnitTester(MultiModule, sourcePath)
diff --git a/scalajslib/test/src/mill/scalajslib/NodeJSConfigTests.scala b/scalajslib/test/src/mill/scalajslib/NodeJSConfigTests.scala
index 730866725fa..3c6b3dca10c 100644
--- a/scalajslib/test/src/mill/scalajslib/NodeJSConfigTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/NodeJSConfigTests.scala
@@ -43,7 +43,7 @@ object NodeJSConfigTests extends TestSuite {
       override def jsEnvConfig = Task { JsEnvConfig.NodeJs(args = nodeArgs) }
 
       object `test-utest` extends ScalaJSTests with TestModule.Utest {
-        override def sources = Task.Sources { millSourcePath / "src/utest" }
+        override def sources = Task.Sources { this.millSourcePath / "src/utest" }
         override def ivyDeps = Agg(
           ivy"com.lihaoyi::utest::$utestVersion"
         )
@@ -51,7 +51,10 @@ object NodeJSConfigTests extends TestSuite {
       }
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "hello-js-world"
diff --git a/scalajslib/test/src/mill/scalajslib/OutputPatternsTests.scala b/scalajslib/test/src/mill/scalajslib/OutputPatternsTests.scala
index 34dbb7f9f6e..4e4aaca417c 100644
--- a/scalajslib/test/src/mill/scalajslib/OutputPatternsTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/OutputPatternsTests.scala
@@ -18,7 +18,10 @@ object OutputPatternsTests extends TestSuite {
       override def scalaJSOutputPatterns = OutputPatterns.fromJSFile("%s.mjs")
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "hello-js-world"
diff --git a/scalajslib/test/src/mill/scalajslib/ScalaTestsErrorTests.scala b/scalajslib/test/src/mill/scalajslib/ScalaTestsErrorTests.scala
index 97d1d3e84e6..6b9f5165af4 100644
--- a/scalajslib/test/src/mill/scalajslib/ScalaTestsErrorTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/ScalaTestsErrorTests.scala
@@ -16,7 +16,10 @@ object ScalaTestsErrorTests extends TestSuite {
         override def hierarchyChecks(): Unit = {}
       }
     }
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   def tests: Tests = Tests {
diff --git a/scalajslib/test/src/mill/scalajslib/SmallModulesForTests.scala b/scalajslib/test/src/mill/scalajslib/SmallModulesForTests.scala
index 25c5c7150b2..07a155406f4 100644
--- a/scalajslib/test/src/mill/scalajslib/SmallModulesForTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/SmallModulesForTests.scala
@@ -15,7 +15,10 @@ object SmallModulesForTests extends TestSuite {
     override def moduleKind = ModuleKind.ESModule
     override def moduleSplitStyle = ModuleSplitStyle.SmallModulesFor(List("app"))
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "small-modules-for"
diff --git a/scalajslib/test/src/mill/scalajslib/SourceMapTests.scala b/scalajslib/test/src/mill/scalajslib/SourceMapTests.scala
index a52ba7edaa3..b83b11552ba 100644
--- a/scalajslib/test/src/mill/scalajslib/SourceMapTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/SourceMapTests.scala
@@ -15,7 +15,10 @@ object SourceMapTests extends TestSuite {
       override def scalaJSSourceMap = false
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "hello-js-world"
diff --git a/scalajslib/test/src/mill/scalajslib/TopLevelExportsTests.scala b/scalajslib/test/src/mill/scalajslib/TopLevelExportsTests.scala
index 6ea7bbaf780..c3eba073ce8 100644
--- a/scalajslib/test/src/mill/scalajslib/TopLevelExportsTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/TopLevelExportsTests.scala
@@ -13,7 +13,10 @@ object TopLevelExportsTests extends TestSuite {
       sys.props.getOrElse("TEST_SCALAJS_VERSION", ???) // at least "1.8.0"
     override def moduleKind = ModuleKind.ESModule
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   val millSourcePath = os.Path(sys.env("MILL_TEST_RESOURCE_DIR")) / "top-level-exports"
diff --git a/scalalib/src/mill/scalalib/CrossSbtModule.scala b/scalalib/src/mill/scalalib/CrossSbtModule.scala
index 82434dc9d50..e80fce57571 100644
--- a/scalalib/src/mill/scalalib/CrossSbtModule.scala
+++ b/scalalib/src/mill/scalalib/CrossSbtModule.scala
@@ -2,7 +2,6 @@ package mill.scalalib
 
 import mill.api.PathRef
 import mill.{T, Task}
-import mill.scalalib.{CrossModuleBase, SbtModule}
 
 import scala.annotation.nowarn
 
diff --git a/scalalib/src/mill/scalalib/Dep.scala b/scalalib/src/mill/scalalib/Dep.scala
index b857131bc50..0c1d41bf351 100644
--- a/scalalib/src/mill/scalalib/Dep.scala
+++ b/scalalib/src/mill/scalalib/Dep.scala
@@ -172,11 +172,11 @@ object Dep {
     (dep: Dep) =>
       unparse(dep) match {
         case Some(s) => ujson.Str(s)
-        case None => upickle.default.writeJs[Dep](dep)(rw0)
+        case None => upickle.default.writeJs[Dep](dep)(using rw0)
       },
     {
       case s: ujson.Str => parse(s.value)
-      case v: ujson.Value => upickle.default.read[Dep](v)(rw0)
+      case v: ujson.Value => upickle.default.read[Dep](v)(using rw0)
     }
   )
 
@@ -279,7 +279,7 @@ object BoundDep {
     upickle.default.readwriter[ujson.Value].bimap[BoundDep](
       bdep => {
         Dep.unparse(Dep(bdep.dep, CrossVersion.Constant("", false), bdep.force)) match {
-          case None => upickle.default.writeJs(bdep)(jsonify0)
+          case None => upickle.default.writeJs(bdep)(using jsonify0)
           case Some(s) => ujson.Str(s)
         }
       },
@@ -287,7 +287,7 @@ object BoundDep {
         case ujson.Str(s) =>
           val dep = Dep.parse(s)
           BoundDep(dep.dep, dep.force)
-        case v => upickle.default.read[BoundDep](v)(jsonify0)
+        case v => upickle.default.read[BoundDep](v)(using jsonify0)
       }
     )
 }
diff --git a/scalalib/src/mill/scalalib/JavaModule.scala b/scalalib/src/mill/scalalib/JavaModule.scala
index 4d92101bcb4..e7da0fb7760 100644
--- a/scalalib/src/mill/scalalib/JavaModule.scala
+++ b/scalalib/src/mill/scalalib/JavaModule.scala
@@ -258,8 +258,10 @@ trait JavaModule
       else compileModuleDepsChecked
     val deps = (normalDeps ++ compileDeps).distinct
     val asString =
-      s"${if (recursive) "Recursive module"
-        else "Module"} dependencies of ${millModuleSegments.render}:\n\t${deps
+      s"${
+          if (recursive) "Recursive module"
+          else "Module"
+        } dependencies of ${millModuleSegments.render}:\n\t${deps
           .map { dep =>
             dep.millModuleSegments.render ++
               (if (compileModuleDepsChecked.contains(dep) || !normalDeps.contains(dep)) " (compile)"
diff --git a/scalalib/src/mill/scalalib/PublishModule.scala b/scalalib/src/mill/scalalib/PublishModule.scala
index cefe014d11f..eb3a7a22f01 100644
--- a/scalalib/src/mill/scalalib/PublishModule.scala
+++ b/scalalib/src/mill/scalalib/PublishModule.scala
@@ -62,10 +62,11 @@ trait PublishModule extends JavaModule { outer =>
   }
 
   def publishXmlDeps: Task[Agg[Dependency]] = Task.Anon {
-    val ivyPomDeps = (ivyDeps() ++ mandatoryIvyDeps()).map(resolvePublishDependency().apply(_))
+    val ivyPomDeps =
+      (ivyDeps() ++ mandatoryIvyDeps()).map(resolvePublishDependency.apply().apply(_))
 
     val compileIvyPomDeps = compileIvyDeps()
-      .map(resolvePublishDependency().apply(_))
+      .map(resolvePublishDependency.apply().apply(_))
       .filter(!ivyPomDeps.contains(_))
       .map(_.copy(scope = Scope.Provided))
 
@@ -314,6 +315,7 @@ object PublishModule extends ExternalModule with TaskModule {
       (payload.map { case (p, f) => (p.path, f) }, meta)
   }
   object PublishData {
+    import mill.scalalib.publish.artifactFormat
     implicit def jsonify: upickle.default.ReadWriter[PublishData] = upickle.default.macroRW
   }
 
diff --git a/scalalib/src/mill/scalalib/ScalaModule.scala b/scalalib/src/mill/scalalib/ScalaModule.scala
index b2b839e5584..c91ef4add7b 100644
--- a/scalalib/src/mill/scalalib/ScalaModule.scala
+++ b/scalalib/src/mill/scalalib/ScalaModule.scala
@@ -11,7 +11,10 @@ import mainargs.Flag
 import mill.scalalib.bsp.{BspBuildTarget, BspModule, ScalaBuildTarget, ScalaPlatform}
 import mill.scalalib.dependency.versions.{ValidVersion, Version}
 
+// this import requires scala-reflect library to be on the classpath
+// it was duplicated to scala3-compiler, but is that too powerful to add as a dependency?
 import scala.reflect.internal.util.ScalaClassLoader
+
 import scala.util.Using
 
 /**
@@ -56,7 +59,7 @@ trait ScalaModule extends JavaModule with TestModule.ScalaModuleBase { outer =>
   def scalaVersion: T[String]
 
   override def mapDependencies: Task[coursier.Dependency => coursier.Dependency] = Task.Anon {
-    super.mapDependencies().andThen { d: coursier.Dependency =>
+    super.mapDependencies().andThen { (d: coursier.Dependency) =>
       val artifacts =
         if (ZincWorkerUtil.isDotty(scalaVersion()))
           Set("dotty-library", "dotty-compiler")
diff --git a/scalalib/src/mill/scalalib/ZincWorkerModule.scala b/scalalib/src/mill/scalalib/ZincWorkerModule.scala
index 611e2482ef3..eb2ebb6f6b1 100644
--- a/scalalib/src/mill/scalalib/ZincWorkerModule.scala
+++ b/scalalib/src/mill/scalalib/ZincWorkerModule.scala
@@ -2,7 +2,6 @@ package mill.scalalib
 
 import coursier.Repository
 import mainargs.Flag
-import mill.Agg
 import mill._
 import mill.api.{Ctx, FixSizedCache, KeyedLockedCache, PathRef, Result}
 import mill.define.{ExternalModule, Discover}
diff --git a/scalalib/src/mill/scalalib/dependency/updates/UpdatesFinder.scala b/scalalib/src/mill/scalalib/dependency/updates/UpdatesFinder.scala
index 863019599d5..3ef00db20d0 100644
--- a/scalalib/src/mill/scalalib/dependency/updates/UpdatesFinder.scala
+++ b/scalalib/src/mill/scalalib/dependency/updates/UpdatesFinder.scala
@@ -74,5 +74,5 @@ private[dependency] object UpdatesFinder {
     case (_, _) => false
   }
 
-  private def isUpdate(current: Version) = current < _
+  private def isUpdate(current: Version) = current < (_: Version)
 }
diff --git a/scalalib/src/mill/scalalib/dependency/versions/VersionParser.scala b/scalalib/src/mill/scalalib/dependency/versions/VersionParser.scala
index d4cb56c816f..ef3757467b8 100644
--- a/scalalib/src/mill/scalalib/dependency/versions/VersionParser.scala
+++ b/scalalib/src/mill/scalalib/dependency/versions/VersionParser.scala
@@ -27,5 +27,5 @@ private[dependency] object VersionParser {
     }
 
   def parse(text: String): Parsed[(Seq[Long], Seq[String], Seq[String])] =
-    fastparse.parse(text, versionParser(_))
+    fastparse.parse(text, versionParser(using _))
 }
diff --git a/scalalib/src/mill/scalalib/giter8/Giter8Module.scala b/scalalib/src/mill/scalalib/giter8/Giter8Module.scala
index c254512d2c8..e7ab57573e2 100644
--- a/scalalib/src/mill/scalalib/giter8/Giter8Module.scala
+++ b/scalalib/src/mill/scalalib/giter8/Giter8Module.scala
@@ -16,11 +16,22 @@ trait Giter8Module extends CoursierModule {
 
   def init(args: String*): Command[Unit] = Task.Command {
     T.log.info("Creating a new project...")
-    val giter8Dependencies = defaultResolver().resolveDeps {
-      val scalaBinVersion = ZincWorkerUtil.scalaBinaryVersion(BuildInfo.scalaVersion)
-      Loose.Agg(ivy"org.foundweekends.giter8:giter8_${scalaBinVersion}:0.14.0"
-        .bindDep("", "", ""))
-    }
+
+    val giter8Dependencies =
+      try {
+        defaultResolver().resolveDeps {
+          val scalaBinVersion = {
+            val bv = ZincWorkerUtil.scalaBinaryVersion(BuildInfo.scalaVersion)
+            if (bv == "3") "2.13" else bv
+          }
+          Loose.Agg(ivy"org.foundweekends.giter8:giter8_${scalaBinVersion}:0.14.0"
+            .bindDep("", "", ""))
+        }
+      } catch {
+        case e: Exception =>
+          T.log.error("Failed to resolve giter8 dependencies\n" + e.getMessage)
+          throw e
+      }
 
     Jvm.runSubprocess(
       "giter8.Giter8",
diff --git a/scalalib/src/mill/scalalib/publish/VersionScheme.scala b/scalalib/src/mill/scalalib/publish/VersionScheme.scala
index 8a53196c37a..6fcba7457b5 100644
--- a/scalalib/src/mill/scalalib/publish/VersionScheme.scala
+++ b/scalalib/src/mill/scalalib/publish/VersionScheme.scala
@@ -33,5 +33,6 @@ object VersionScheme {
   case object Strict extends VersionScheme("strict")
   implicit val rwStrict: ReadWriter[Strict.type] = macroRW
 
-  implicit val rwVersionScheme: ReadWriter[VersionScheme.type] = macroRW
+  // edit @bishabosha: why was it `.type`, I assume it is meant to infer a sum type?
+  implicit val rwVersionScheme: ReadWriter[VersionScheme /*.type*/ ] = macroRW
 }
diff --git a/scalanativelib/test/src/mill/scalanativelib/CompileRunTests.scala b/scalanativelib/test/src/mill/scalanativelib/CompileRunTests.scala
index 5c78f4138b7..121080cb301 100644
--- a/scalanativelib/test/src/mill/scalanativelib/CompileRunTests.scala
+++ b/scalanativelib/test/src/mill/scalanativelib/CompileRunTests.scala
@@ -60,7 +60,7 @@ object CompileRunTests extends TestSuite {
       )
 
       object test extends ScalaNativeTests with TestModule.Utest {
-        override def sources = Task.Sources { millSourcePath / "src/utest" }
+        override def sources = Task.Sources { this.millSourcePath / "src/utest" }
         override def ivyDeps = super.ivyDeps() ++ Agg(
           ivy"com.lihaoyi::utest::$utestVersion"
         )
diff --git a/scalanativelib/test/src/mill/scalanativelib/ExclusionsTests.scala b/scalanativelib/test/src/mill/scalanativelib/ExclusionsTests.scala
index 4947f2962cc..d3698c0c587 100644
--- a/scalanativelib/test/src/mill/scalanativelib/ExclusionsTests.scala
+++ b/scalanativelib/test/src/mill/scalanativelib/ExclusionsTests.scala
@@ -1,5 +1,6 @@
 package mill.scalanativelib
 
+import mill.given
 import mill.Agg
 import mill.scalalib._
 import mill.define.Discover
diff --git a/scalanativelib/test/src/mill/scalanativelib/FeaturesTests.scala b/scalanativelib/test/src/mill/scalanativelib/FeaturesTests.scala
index a796c0c9542..9df8455f8fc 100644
--- a/scalanativelib/test/src/mill/scalanativelib/FeaturesTests.scala
+++ b/scalanativelib/test/src/mill/scalanativelib/FeaturesTests.scala
@@ -1,5 +1,6 @@
 package mill.scalanativelib
 
+import mill.given
 import mill.define.Discover
 import mill.testkit.UnitTester
 import mill.testkit.TestBaseModule
diff --git a/scalanativelib/test/src/mill/scalanativelib/ScalaTestsErrorTests.scala b/scalanativelib/test/src/mill/scalanativelib/ScalaTestsErrorTests.scala
index e8b94860296..48c9d85a270 100644
--- a/scalanativelib/test/src/mill/scalanativelib/ScalaTestsErrorTests.scala
+++ b/scalanativelib/test/src/mill/scalanativelib/ScalaTestsErrorTests.scala
@@ -17,7 +17,10 @@ object ScalaTestsErrorTests extends TestSuite {
       }
     }
 
-    override lazy val millDiscover = Discover[this.type]
+    override lazy val millDiscover = {
+      import mill.main.TokenReaders.given
+      Discover[this.type]
+    }
   }
 
   def tests: Tests = Tests {
diff --git a/testkit/src/mill/testkit/IntegrationTester.scala b/testkit/src/mill/testkit/IntegrationTester.scala
index 043b530a5c5..982e2ad672f 100644
--- a/testkit/src/mill/testkit/IntegrationTester.scala
+++ b/testkit/src/mill/testkit/IntegrationTester.scala
@@ -105,7 +105,7 @@ object IntegrationTester {
        * Returns the raw text of the `.json` metadata file
        */
       def text: String = {
-        val Seq((List(selector), _)) =
+        val Seq((Seq(selector), _)) =
           mill.resolve.ParseArgs.apply(Seq(selector0), SelectMode.Separated).getOrElse(???)
 
         val segments = selector._2.getOrElse(Segments()).value.flatMap(_.pathSegments)
diff --git a/testkit/src/mill/testkit/UnitTester.scala b/testkit/src/mill/testkit/UnitTester.scala
index 90768b2fc13..3740cf3f24f 100644
--- a/testkit/src/mill/testkit/UnitTester.scala
+++ b/testkit/src/mill/testkit/UnitTester.scala
@@ -189,7 +189,7 @@ class UnitTester(
   }
 
   def close(): Unit = {
-    for ((_, Val(obsolete: AutoCloseable)) <- evaluator.workerCache.values) {
+    for (case (_, Val(obsolete: AutoCloseable)) <- evaluator.workerCache.values) {
       obsolete.close()
     }
   }