Support mill init from an existing sbt project

.github/actions/post-build-setup/action.yml

@@ -34,4 +34,6 @@ runs:
         name: ${{ inputs.os }}-selective-execution-artifact
 
     - run: mv out/mill-selective-execution/mill-selective-execution.json out/mill-selective-execution.json
-      shell: bash
+      shell: bash
+
+    - uses: sbt/setup-sbt@v1

.github/actions/pre-build-setup/action.yml

@@ -65,4 +65,4 @@ runs:
     - uses: actions/checkout@v4
 
     - run: echo temurin:${{ inputs.java-version }} > .mill-jvm-version
-      shell: bash
+      shell: bash

.github/workflows/autofix.yml

@@ -7,6 +7,8 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - uses: sbt/setup-sbt@v1
+
       - run: |
           ./mill __.fix + mill.javalib.palantirformat.PalantirFormatModule/ + mill.scalalib.scalafmt.ScalafmtModule/ + mill.kotlinlib.ktlint.KtlintModule/
           ./mill --meta-level 1 mill.scalalib.scalafmt.ScalafmtModule/

build.mill

@@ -53,8 +53,11 @@ object Deps {
   // and then add to it `bridgeScalaVersions`
   val scalaVersion = "3.6.2"
   val scala2Version = "2.13.15"
+  // The Scala 2.12.x version
+  val scalaVersion212 = "2.12.20"
   // The Scala 2.12.x version to use for some workers
-  val workerScalaVersion212 = "2.12.20"
+  val workerScalaVersion212 = scalaVersion212
+  val sbtScalaVersion212 = scalaVersion212
 
   val testScala213Version = "2.13.15"
   // Scala Native 4.2 will not get releases for new Scala version
@@ -194,7 +197,8 @@ object Deps {
   val sourcecode = ivy"com.lihaoyi::sourcecode:0.4.3-M5"
   val upickle = ivy"com.lihaoyi::upickle:4.1.0"
   val windowsAnsi = ivy"io.github.alexarchambault.windows-ansi:windows-ansi:0.0.6"
-  val zinc = ivy"org.scala-sbt::zinc:1.10.7".withDottyCompat(scalaVersion)
+  val sbtVersion = "1.10.7"
+  val zinc = ivy"org.scala-sbt::zinc:$sbtVersion".withDottyCompat(scalaVersion)
   // keep in sync with doc/antora/antory.yml
   val bsp4j = ivy"ch.epfl.scala:bsp4j:2.2.0-M2"
   val fansi = ivy"com.lihaoyi::fansi:0.5.0"
@@ -220,6 +224,7 @@ object Deps {
     ivy"org.apache.maven.resolver:maven-resolver-transport-wagon:$mavenResolverVersion"
   val coursierJvmIndexVersion = "0.0.4-84-f852c6"
   val gradleApi = ivy"dev.gradleplugins:gradle-api:8.11.1"
+  val sbt = ivy"org.scala-sbt:sbt:$sbtVersion"
 
   object RuntimeDeps {
     val dokkaVersion = "2.0.0"
@@ -714,16 +719,18 @@ trait MillStableScalaModule extends MillPublishScalaModule with Mima {
   }
 }
 
+trait MillPublishCrossScalaModule extends MillPublishJavaModule with CrossScalaModule
+
 object bridge extends Cross[BridgeModule](compilerBridgeScalaVersions)
-trait BridgeModule extends MillPublishJavaModule with CrossScalaModule {
+trait BridgeModule extends MillPublishCrossScalaModule {
   def scalaVersion = crossScalaVersion
   def publishVersion = bridgeVersion
   def artifactName = "mill-scala-compiler-bridge"
   def pomSettings = commonPomSettings(artifactName())
   def crossFullScalaVersion = true
   def ivyDeps = Agg(
-    ivy"org.scala-sbt:compiler-interface:${Deps.zinc.version}",
-    ivy"org.scala-sbt:util-interface:${Deps.zinc.version}"
+    ivy"org.scala-sbt:compiler-interface:${Deps.sbtVersion}",
+    ivy"org.scala-sbt:util-interface:${Deps.sbtVersion}"
   ) ++ Agg(
     if (ZincWorkerUtil.isScala3(crossScalaVersion))
       ivy"org.scala-lang::scala3-compiler:${crossScalaVersion}"
@@ -738,7 +745,7 @@ trait BridgeModule extends MillPublishJavaModule with CrossScalaModule {
   def compilerBridgeIvyDeps: T[Agg[Dep]] = Agg(
     (if (ZincWorkerUtil.isScala3(crossScalaVersion))
        ivy"org.scala-lang:scala3-sbt-bridge:${crossScalaVersion}"
-     else ivy"org.scala-sbt::compiler-bridge:${Deps.zinc.version}").exclude("*" -> "*")
+     else ivy"org.scala-sbt::compiler-bridge:${Deps.sbtVersion}").exclude("*" -> "*")
   )
 
   def compilerBridgeSourceJars: T[Agg[PathRef]] = Task {

dist/package.mill

@@ -75,6 +75,7 @@ object `package` extends RootModule with InstallModule {
       build.main.graphviz.testDep(),
       build.main.init.maven.testDep(),
       build.main.init.gradle.testDep(),
+      build.main.init.sbt.testDep(),
       build.scalalib.backgroundwrapper.testDep(),
       build.contrib.bloop.testDep(),
       build.contrib.buildinfo.testDep(),

example/package.mill

@@ -64,6 +64,7 @@ object `package` extends RootModule with Module {
     object web extends Cross[ExampleCrossModule](build.listIn(millSourcePath / "web"))
     object native extends Cross[ExampleCrossModule](build.listIn(millSourcePath / "native"))
     object spark extends Cross[ExampleCrossModule](build.listIn(millSourcePath / "spark"))
+    object migrating extends Cross[ExampleCrossModule](build.listIn(millSourcePath / "migrating"))
   }
   object javascriptlib extends Module {
     object basic extends Cross[ExampleCrossModule](build.listIn(millSourcePath / "basic"))

example/scalalib/migrating/1-sbt-complete/build.mill

@@ -0,0 +1,23 @@
+/** Usage
+
+> rm build.mill # remove any existing build file
+
+> git init .
+> git remote add -f origin https://github.com/scalacenter/library-example.git
+> git checkout v1.0.1
+
+> ./mill init
+converting module library-example
+Dependency Dependency(com.lightbend.paradox,paradox-theme-generic,false,0.4.4,Some(paradox-theme)) with an unknown configuration "paradox-theme" is dropped.
+Dependency Dependency(com.lightbend.paradox,paradox-theme-generic,false,0.4.4,Some(paradox-theme)) with an unknown configuration "paradox-theme" is dropped.
+generated 1 Mill build file(s)
+removing existing Mill build files
+writing Mill build file to build.mill
+converted sbt build to Mill
+formatting Mill build files
+Formatting 1 Scala sources
+init completed, run "mill resolve _" to list available tasks
+
+> ./mill compile
+done compiling
+*/

example/scalalib/migrating/2-sbt-incomplete/build.mill

@@ -0,0 +1,25 @@
+/** Usage
+
+> rm build.mill # remove any existing build file
+
+> git init .
+> git remote add -f origin https://github.com/tototoshi/scala-csv.git
+> git checkout 2.0.0
+
+> ./mill init
+converting sbt build
+Running the added `millInitExportBuild` sbt task to export the build
+converting module scala-csv
+generated 1 Mill build file(s)
+removing existing Mill build files
+writing Mill build file to build.mill
+converted sbt build to Mill
+formatting Mill build files
+Formatting 1 Scala sources
+init completed, run "mill resolve _" to list available tasks
+
+> ./mill compile # You will have to further configure the `CrossScalaModule` for different Scala versions
+error: class CSVReader protected (private val lineReader: LineReader)(implicit format: CSVFormat) extends Closeable with CSVReaderCompat {
+error:                                                                                                                   ^
+error: one error found
+*/

integration/feature/init/src/IntegrationTesterExt.scala

@@ -0,0 +1,78 @@
+package mill.integration
+
+import mill.testkit.IntegrationTester
+import utest.*
+
+val defaultInitCommand =
+  Seq("init", "--base-module", "BaseModule", "--deps-object", "Deps", "--merge")
+
+case class SplitResolvedTasks(successful: Seq[String], failed: Seq[String]) {
+  val all = (successful ++ failed).sorted
+}
+
+extension (tester: IntegrationTester)
+  /**
+   * @param expectedCompileTasks [[ None ]] to denote that the `resolve __.compile` task fails
+   * @param expectedTestTasks [[ None ]] to denote that the `resolve __.test` task fails
+   * @return
+   */
+  def testMillInit(
+      initCommand: Seq[String] = defaultInitCommand,
+      expectedInitResult: Boolean = true,
+      // expectedCompileResult: Boolean,
+      expectedCompileTasks: Option[SplitResolvedTasks],
+      expectedTestTasks: Option[SplitResolvedTasks]
+  ) = {
+    import tester.*
+
+    val initResult = eval(initCommand, stdout = os.Inherit, stderr = os.Inherit)
+    assert(initResult.isSuccess == expectedInitResult)
+
+    /*
+    val compileResult = eval("compile")
+    assert(compileResult.isSuccess == expectedCompileResult)
+     */
+
+    def testAllResolvedTasks(taskName: String, expected: Option[SplitResolvedTasks]) = {
+      val resolveAllTasksResult = eval(("resolve", s"__.$taskName"))
+      expected.fold(
+        assert(!resolveAllTasksResult.isSuccess)
+      )(expected => {
+        assert(resolveAllTasksResult.isSuccess)
+        val resolvedAllTasks = resolveAllTasksResult.out.linesIterator.toSeq.sorted
+        Predef.assert(
+          expected.all == resolvedAllTasks,
+          s"""
+             |expected: ${expected.all}
+             |resolved: $resolvedAllTasks
+             |""".stripMargin
+        )
+
+        for (task <- expected.successful)
+          Predef.assert(eval(task).isSuccess, s"task $task failed")
+
+        for (task <- expected.failed)
+          Predef.assert(!eval(task).isSuccess, s"task $task succeeded")
+      })
+    }
+
+    testAllResolvedTasks("compile", expectedCompileTasks)
+    testAllResolvedTasks("test", expectedTestTasks)
+  }
+
+extension (module: String) {
+  def compileTask: String =
+    s"$module.compile"
+  private def testModuleOrTask: String =
+    s"$module.test"
+  def testTask: String =
+    testModuleOrTask
+  def testModule: String =
+    testModuleOrTask
+  def testCompileTask: String =
+    testModule.compileTask
+  def testTestTask: String =
+    testModule.testTask
+  def allCompileTasks: Seq[String] =
+    Seq(compileTask, testCompileTask)
+}