WIP Replace Seq[String] used for options by mill.api.opt.Opts

Author: lefou

contrib/jmh/src/mill/contrib/jmh/JmhModule.scala

@@ -77,7 +77,7 @@ trait JmhModule extends JavaModule {
   def generateBenchmarkSources =
     Task {
       val dest = Task.ctx().dest
-      val forkedArgs = forkArgs().toSeq
+      val forkedArgs = forkArgs().toStringSeq
       val sourcesDir = dest / "jmh_sources"
       val resourcesDir = dest / "jmh_resources"
 

contrib/scoverage/src/mill/contrib/scoverage/ScoverageModule.scala

@@ -1,10 +1,9 @@
 package mill.contrib.scoverage
 
 import coursier.Repository
-import mill._
-import mill.api.{PathRef}
-import mill.api.BuildCtx
-import mill.api.{Result}
+import mill.*
+import mill.api.{BuildCtx, PathRef, Result}
+import mill.api.opt.*
 import mill.contrib.scoverage.api.ScoverageReportWorkerApi2.ReportType
 import mill.util.BuildInfo
 import mill.javalib.api.JvmWorkerUtil
@@ -168,18 +167,18 @@ trait ScoverageModule extends ScalaModule { outer: ScalaModule =>
       Task { outer.scalacPluginMvnDeps() ++ outer.scoveragePluginDeps() }
 
     /** Add the scoverage specific plugin settings (`dataDir`). */
-    override def scalacOptions: T[Seq[String]] =
+    override def scalacOptions: T[Opts] =
       Task {
         val extras =
           if (isScala3()) {
-            Seq(
-              s"-coverage-out:${data().path.toIO.getPath()}",
-              s"-sourceroot:${BuildCtx.workspaceRoot}"
+            Opts(
+              opt"-coverage-out:${data().path}",
+              opt"-sourceroot:${BuildCtx.workspaceRoot}"
             )
           } else {
-            Seq(
-              s"-P:scoverage:dataDir:${data().path.toIO.getPath()}",
-              s"-P:scoverage:sourceRoot:${BuildCtx.workspaceRoot}"
+            Opts(
+              opt"-P:scoverage:dataDir:${data().path}",
+              opt"-P:scoverage:sourceRoot:${BuildCtx.workspaceRoot}"
             )
           }
 

core/api/daemon/src/mill/api/daemon/internal/JavaModuleApi.scala

@@ -13,8 +13,8 @@ trait JavaModuleApi extends ModuleApi with GenIdeaModuleApi {
 
   def transitiveModuleCompileModuleDeps: Seq[JavaModuleApi]
 
-  def javacOptions: TaskApi[Seq[String]]
-  def mandatoryJavacOptions: TaskApi[Seq[String]]
+  def javacOptions: TaskApi[OptsApi]
+  def mandatoryJavacOptions: TaskApi[OptsApi]
 
   // BSP Tasks that sometimes need to be customized
 

core/api/daemon/src/mill/api/daemon/internal/bsp/BspJavaModuleApi.scala

@@ -1,6 +1,6 @@
 package mill.api.daemon.internal.bsp
 
-import mill.api.daemon.internal.{EvaluatorApi, ModuleApi, TaskApi}
+import mill.api.daemon.internal.{EvaluatorApi, ModuleApi, OptApi, OptsApi, TaskApi}
 
 import java.nio.file.Path
 
@@ -34,21 +34,25 @@ trait BspJavaModuleApi extends ModuleApi {
   )
       : TaskApi[EvaluatorApi => (
           classesPath: Path,
-          javacOptions: Seq[String],
+          javacOptions: OptsApi,
           classpath: Seq[String]
       )]
 
   private[mill] def bspBuildTargetScalacOptions(
       needsToMergeResourcesIntoCompileDest: Boolean,
       enableJvmCompileClasspathProvider: Boolean,
       clientWantsSemanticDb: Boolean
-  ): TaskApi[(Seq[String], EvaluatorApi => Seq[String], EvaluatorApi => java.nio.file.Path)]
+  ): TaskApi[(
+      scalacOptionsTask: OptsApi,
+      compileClasspathTask: EvaluatorApi => Seq[String],
+      classPathTask: EvaluatorApi => java.nio.file.Path
+  )]
 
   private[mill] def bspBuildTargetScalaMainClasses
       : TaskApi[(
           classes: Seq[String],
-          forkArgs: Seq[String],
-          forkEnv: Map[String, String]
+          forkArgs: OptsApi,
+          forkEnv: Map[String, OptApi]
       )]
 
   private[mill] def bspLoggingTest: TaskApi[Unit]

core/api/daemon/src/mill/api/daemon/internal/bsp/BspRunModuleApi.scala

@@ -1,6 +1,6 @@
 package mill.api.daemon.internal.bsp
 
-import mill.api.daemon.internal.{ModuleApi, TaskApi}
+import mill.api.daemon.internal.{ModuleApi, OptApi, OptsApi, TaskApi}
 
 import java.nio.file.Path
 
@@ -10,18 +10,18 @@ trait BspRunModuleApi extends ModuleApi {
 
   private[mill] def bspJvmRunEnvironment: TaskApi[(
       runClasspath: Seq[Path],
-      forkArgs: Seq[String],
+      forkArgs: OptsApi,
       forkWorkingDir: Path,
-      forkEnv: Map[String, String],
+      forkEnv: Map[String, OptApi],
       mainClass: Option[String],
       localMainClasses: Seq[String]
   )]
 
   private[mill] def bspJvmTestEnvironment: TaskApi[(
       runClasspath: Seq[Path],
-      forkArgs: Seq[String],
+      forkArgs: OptsApi,
       forkWorkingDir: Path,
-      forkEnv: Map[String, String],
+      forkEnv: Map[String, OptApi],
       mainClass: Option[String],
       testEnvVars: Option[(
           mainClass: String,

libs/androidlib/src/mill/androidlib/AndroidAppKotlinModule.scala

@@ -2,6 +2,7 @@ package mill.androidlib
 
 import coursier.params.ResolutionParams
 import mill.api.{ModuleRef, PathRef, Task}
+import mill.api.opt.*
 import mill.kotlinlib.{Dep, DepSyntax}
 import mill.javalib.TestModule.Junit5
 import mill.javalib.{JavaModule, TestModule}
@@ -293,7 +294,7 @@ trait AndroidAppKotlinModule extends AndroidKotlinModule, AndroidAppModule { out
       PathRef(diffImageDir)
     }
 
-    override def forkArgs: T[Seq[String]] = super.forkArgs() ++ testJvmArgs()
+    override def forkArgs: T[Opts] = super.forkArgs() ++ testJvmArgs()
     override def runClasspath: T[Seq[PathRef]] =
       super.runClasspath() ++ androidPreviewScreenshotTestEngineClasspath() ++ compileClasspath()
 
@@ -315,18 +316,18 @@ trait AndroidAppKotlinModule extends AndroidKotlinModule, AndroidAppModule { out
     As defined in
     [[https://android.googlesource.com/platform/tools/base/+/61923408e5f7dc20f0840844597f9dde17453a0f/preview/screenshot/screenshot-test-gradle-plugin/src/main/java/com/android/compose/screenshot/tasks/PreviewScreenshotValidationTask.kt?#84]]
      */
-    private def testJvmArgs: T[Seq[String]] = Task {
+    private def testJvmArgs: T[Opts] = Task {
       val params = Map(
-        "previews-discovered" -> androidDiscoveredPreviews().previewsDiscoveredJsonFile.path.toString(),
-        "referenceImageDirPath" -> screenshotResults().path.toString(),
-        "diffImageDirPath" -> diffImageDirPath().path.toString,
-        "renderResultsFilePath" -> androidScreenshotGeneratedResults().path.toString,
-        "renderTaskOutputDir" -> screenshotResults().path.toString(),
-        "resultsDirPath" -> androidScreenshotTestResultDir().path.toString(),
+        "previews-discovered" -> androidDiscoveredPreviews().previewsDiscoveredJsonFile.path,
+        "referenceImageDirPath" -> screenshotResults().path,
+        "diffImageDirPath" -> diffImageDirPath().path,
+        "renderResultsFilePath" -> androidScreenshotGeneratedResults().path,
+        "renderTaskOutputDir" -> screenshotResults().path,
+        "resultsDirPath" -> androidScreenshotTestResultDir().path,
         "threshold" -> androidScreenshotTestDiffThreshold.toString
       )
 
-      params.map { case (k, v) => s"$JvmTestArg$k=$v" }.toSeq
+      Opts(params.map { case (k, v) => opt"$JvmTestArg$k=$v" })
     }
 
     private val JvmTestArg = "-Dcom.android.tools.preview.screenshot.junit.engine."

libs/androidlib/src/mill/androidlib/AndroidKotlinModule.scala

@@ -2,15 +2,11 @@ package mill.androidlib
 
 import mill.*
 import mill.api.{ModuleRef, PathRef, Result}
+import mill.api.opt.*
 import mill.javalib.{CoursierModule, Dep}
-import mill.kotlinlib.{Dep, DepSyntax, KotlinModule}
+import mill.kotlinlib.{Dep, DepSyntax, KotlinModule, KotlincOptions}
 import mill.{T, Task}
-import mill.androidlib.databinding.{
-  AndroidDataBindingWorker,
-  GenerateBindingSourcesArgs,
-  ProcessResourcesArgs,
-  AndroidDataBindingWorkerModule
-}
+import mill.androidlib.databinding.{AndroidDataBindingWorker, AndroidDataBindingWorkerModule, GenerateBindingSourcesArgs, ProcessResourcesArgs}
 import mill.util.Jvm
 
 // TODO expose Compose configuration options
@@ -185,21 +181,26 @@ trait AndroidKotlinModule extends KotlinModule with AndroidModule { outer =>
    * If this module has any module dependencies, we need to tell the kotlin compiler to
    * handle the compiled output as a friend path so top level declarations are visible.
    */
-  def kotlincFriendPaths: T[Option[String]] = Task {
+  def kotlincFriendPaths: T[Opts] = Task {
     val compiledCodePaths = Task.traverse(transitiveModuleCompileModuleDeps)(m =>
       Task.Anon {
         Seq(m.compile().classes.path)
       }
     )().flatten
 
-    val friendlyPathFlag: Option[String] =
-      compiledCodePaths.headOption.map(_ => s"-Xfriend-paths=${compiledCodePaths.mkString(",")}")
-
-    friendlyPathFlag
+    Opts(
+      OptGroup.when(compiledCodePaths.nonEmpty)(
+        Opt.mkPath(
+          compiledCodePaths,
+          prefix = KotlincOptions.`-Xfriend-paths`,
+          sep = KotlincOptions.friendPathSeparator
+        )
+      )
+    )
   }
 
-  override def kotlincOptions: T[Seq[String]] = Task {
-    super.kotlincOptions() ++ kotlincFriendPaths().toSeq
+  override def kotlincOptions: T[Opts] = Task {
+    super.kotlincOptions() ++ kotlincFriendPaths()
   }
 
   def kspDependencyResolver: Task[CoursierModule.Resolver] = Task.Anon {

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

@@ -516,7 +516,7 @@ trait AndroidModule extends JavaModule { outer =>
    * The Java compiled classes of [[androidResources]]
    */
   def androidCompiledRClasses: T[CompilationResult] = Task(persistent = true) {
-    val jOpts = JavaCompilerOptions.split(javacOptions() ++ mandatoryJavacOptions())
+    val jOpts = JavaCompilerOptions.split(javacOptions().toStringSeq ++ mandatoryJavacOptions().toStringSeq)
     val worker = jvmWorker().internalWorker()
     worker.apply(
       ZincCompileJava(
@@ -728,7 +728,7 @@ trait AndroidModule extends JavaModule { outer =>
 
     val rJar = Task.dest / "R.jar"
 
-    val jOpts = JavaCompilerOptions.split(javacOptions() ++ mandatoryJavacOptions())
+    val jOpts = JavaCompilerOptions.split(javacOptions().toStringSeq ++ mandatoryJavacOptions().toStringSeq)
     val worker = jvmWorker().internalWorker()
     val classesDest = worker
       .apply(

libs/androidlib/src/mill/androidlib/hilt/AndroidHiltSupport.scala

@@ -1,6 +1,7 @@
 package mill.androidlib.hilt
 
 import mill.androidlib.AndroidKotlinModule
+import mill.api.opt.*
 import mill.api.{ModuleRef, PathRef}
 import mill.kotlinlib.ksp.KspModule
 import mill.javalib.Dep
@@ -24,12 +25,12 @@ import mill.{T, Task}
 @mill.api.experimental
 trait AndroidHiltSupport extends KspModule, AndroidKotlinModule {
 
-  override def kspProcessorOptions: T[Map[String, String]] = Task {
+  override def kspProcessorOptions: T[Map[String, Opt]] = Task {
     super.kspProcessorOptions() ++ Map(
-      "dagger.fastInit" -> "enabled",
-      "dagger.hilt.android.internal.disableAndroidSuperclassValidation" -> "true",
-      "dagger.hilt.android.internal.projectType" -> "APP",
-      "dagger.hilt.internal.useAggregatingRootProcessor" -> "true"
+      "dagger.fastInit" -> opt"enabled",
+      "dagger.hilt.android.internal.disableAndroidSuperclassValidation" -> opt"true",
+      "dagger.hilt.android.internal.projectType" -> opt"APP",
+      "dagger.hilt.internal.useAggregatingRootProcessor" -> opt"true"
     )
   }
 

libs/javalib/src/mill/javalib/AssemblyModule.scala

@@ -4,6 +4,7 @@ import mill.api.PathRef
 import mill.api.Result
 import mill.util.JarManifest
 import mill.api.*
+import mill.api.opt.*
 import mill.api.Task.Simple as T
 import mill.javalib.Assembly.UnopenedInputStream
 import mill.util.Jvm
@@ -16,17 +17,17 @@ trait AssemblyModule extends mill.api.Module {
 
   def finalMainClassOpt: T[Either[String, String]]
 
-  def forkArgs: T[Seq[String]]
+  def forkArgs: T[Opts]
 
   /**
    * Similar to `forkArgs` but only applies to the `sh` launcher script
    */
-  def forkShellArgs: T[Seq[String]] = Task { Seq.empty[String] }
+  def forkShellArgs: T[Opts] = Task { Opts() }
 
   /**
    * Similar to `forkArgs` but only applies to the `bat` launcher script
    */
-  def forkCmdArgs: T[Seq[String]] = Task { Seq.empty[String] }
+  def forkCmdArgs: T[Opts] = Task { Opts() }
 
   /**
    * Creates a manifest representation which can be modified or replaced
@@ -54,10 +55,10 @@ trait AssemblyModule extends mill.api.Module {
           mainClass = cls,
           shellClassPath = Seq("$0"),
           cmdClassPath = Seq("%~dpnx0"),
-          jvmArgs = forkArgs(),
+          jvmArgs = forkArgs().toStringSeq,
           shebang = false,
-          shellJvmArgs = forkShellArgs(),
-          cmdJvmArgs = forkCmdArgs()
+          shellJvmArgs = forkShellArgs().toStringSeq,
+          cmdJvmArgs = forkCmdArgs().toStringSeq
         )
     }
   }