Added new implementation for SBT importer with support for cross-platform and cross version projects

Cross-platform support is limited to projects using `sbt-crossproject` plugin and was achieved with custom layout supertypes that replicate the project structure used by the plugin.

Project settings are imported by running a custom script in the SBT shell. This means that the values imported are for the default Scala version used in the project. Post import, running Mill tasks with a different version may result in failures. For now, a warning message is logged notifying the user of this possibility.

Author: ajaychandran

libs/init/migrate/api/src/mill/init/migrate/ModuleConfig.scala

@@ -0,0 +1,108 @@
+package mill.init.migrate
+
+import upickle.default.{ReadWriter, macroRW}
+
+sealed trait ModuleConfig
+object ModuleConfig {
+  implicit val rw: ReadWriter[ModuleConfig] = macroRW
+}
+
+case class CoursierModuleConfig(repositories: Seq[String] = Nil) extends ModuleConfig
+object CoursierModuleConfig {
+  implicit val rw: ReadWriter[CoursierModuleConfig] = macroRW
+}
+
+case class JavaModuleConfig(
+    mvnDeps: Seq[String] = Nil,
+    compileMvnDeps: Seq[String] = Nil,
+    runMvnDeps: Seq[String] = Nil,
+    moduleDeps: Seq[JavaModuleConfig.ModuleDep] = Nil,
+    compileModuleDeps: Seq[JavaModuleConfig.ModuleDep] = Nil,
+    runModuleDeps: Seq[JavaModuleConfig.ModuleDep] = Nil,
+    javacOptions: Seq[String] = Nil
+) extends ModuleConfig
+object JavaModuleConfig {
+  case class ModuleDep(segments: Seq[String], crossArgs: Map[Int, String] = Map())
+  object ModuleDep {
+    implicit val rw: ReadWriter[ModuleDep] = macroRW
+  }
+  implicit val rw: ReadWriter[JavaModuleConfig] = macroRW
+}
+
+case class PublishModuleConfig(
+    pomSettings: PublishModuleConfig.PomSettings,
+    publishVersion: String,
+    versionScheme: Option[String] = None
+) extends ModuleConfig
+object PublishModuleConfig {
+  case class Artifact(group: String, id: String, verison: String)
+  object Artifact {
+    implicit val rw: ReadWriter[Artifact] = macroRW
+  }
+  case class License(
+      id: String,
+      name: String,
+      url: String = "",
+      isOsiApproved: Boolean = false,
+      isFsfLibre: Boolean = false,
+      distribution: String = ""
+  )
+  object License {
+    implicit val rw: ReadWriter[License] = macroRW
+  }
+  case class VersionControl(
+      browsableRepository: Option[String] = None,
+      connection: Option[String] = None,
+      developerConnection: Option[String] = None,
+      tag: Option[String] = None
+  )
+  object VersionControl {
+    implicit val rw: ReadWriter[VersionControl] = macroRW
+  }
+  case class Developer(
+      id: String,
+      name: String,
+      url: String,
+      organization: Option[String] = None,
+      organizationUrl: Option[String] = None
+  )
+  object Developer {
+    implicit val rw: ReadWriter[Developer] = macroRW
+  }
+  case class PomSettings(
+      description: String,
+      organization: String,
+      url: String,
+      licenses: Seq[License] = Nil,
+      versionControl: VersionControl = VersionControl(),
+      developers: Seq[Developer] = Nil
+  )
+  object PomSettings {
+    implicit val rw: ReadWriter[PomSettings] = macroRW
+  }
+  sealed trait VersionScheme
+  object VersionScheme {
+    case object Early
+  }
+
+  implicit val rw: ReadWriter[PublishModuleConfig] = macroRW
+}
+
+case class ScalaModuleConfig(
+    scalaVersion: String = "",
+    scalacOptions: Seq[String] = Nil,
+    scalacPluginMvnDeps: Seq[String] = Nil
+) extends ModuleConfig
+object ScalaModuleConfig {
+  implicit val rw: ReadWriter[ScalaModuleConfig] = macroRW
+}
+
+case class ScalaJSModuleConfig(scalaJSVersion: String = "") extends ModuleConfig
+object ScalaJSModuleConfig {
+  implicit val rw: ReadWriter[ScalaJSModuleConfig] = macroRW
+}
+
+case class ScalaNativeModuleConfig(scalaNativeVersion: String = "") extends ModuleConfig
+object ScalaNativeModuleConfig {
+  implicit val rw: ReadWriter[ScalaNativeModuleConfig] = macroRW
+}

libs/init/migrate/api/src/mill/init/migrate/ModuleRepr.scala

@@ -0,0 +1,8 @@
+package mill.init.migrate
+
+import upickle.default.{ReadWriter, macroRW}
+
+case class ModuleRepr(main: ModuleTypedef = ModuleTypedef(), test: Option[ModuleTypedef] = None)
+object ModuleRepr {
+  implicit val rw: ReadWriter[ModuleRepr] = macroRW
+}

libs/init/migrate/api/src/mill/init/migrate/ModuleTypedef.scala

@@ -0,0 +1,56 @@
+package mill.init.migrate
+
+import upickle.default.{ReadWriter, macroRW}
+
+case class ModuleTypedef(name: String, supertypes: Seq[String], configs: Seq[ModuleConfig]) {
+
+  def extend(supertypes: String*): ModuleTypedef =
+    copy(supertypes = this.supertypes ++ supertypes)
+}
+object ModuleTypedef {
+
+  def apply(name: String = "package", configs: Seq[ModuleConfig] = Nil): ModuleTypedef =
+    apply(name, computeSupertypes(configs), configs)
+
+  def computeSupertypes(configs: Seq[ModuleConfig]) = {
+    var supertypes = configs.collectFirst {
+      case _: ScalaJSModuleConfig => "ScalaJSModule"
+      case _: ScalaNativeModuleConfig => "ScalaNativeModule"
+    }.toSeq
+    if (supertypes.isEmpty && configs.exists(_.isInstanceOf[ScalaModuleConfig]))
+      supertypes :+= "ScalaModule"
+    if (configs.exists(_.isInstanceOf[PublishModuleConfig])) supertypes :+= "PublishModule"
+    if (supertypes.isEmpty && configs.exists(_.isInstanceOf[JavaModuleConfig]))
+      supertypes :+= "JavaModule"
+    if (supertypes.isEmpty && configs.exists(_.isInstanceOf[CoursierModuleConfig]))
+      supertypes :+= "CoursierModule"
+    if (supertypes.isEmpty) Seq("Module") else supertypes
+  }
+
+  def computeTestSupertypes(mainSupertypes: Seq[String]) = {
+    var supertypes = mainSupertypes.collectFirst {
+      case "ScalaJSModule" => "ScalaJSTests"
+      case "ScalaNativeModule" => "ScalaNativeTests"
+    }.toSeq
+    if (supertypes.isEmpty && mainSupertypes.contains("ScalaModule"))
+      supertypes :+= "ScalaTests"
+    if (supertypes.isEmpty && mainSupertypes.contains("JavaModule"))
+      supertypes :+= "JavaTests"
+    supertypes
+  }
+
+  val testSupertypeByDepOrg = Map(
+    "junit" -> "TestModule.Junit4",
+    "org.junit.jupiter" -> "TestModule.Junit5",
+    "org.testng" -> "TestModule.TestNg",
+    "org.scalatest" -> "TestModule.ScalaTest",
+    "org.specs2" -> "TestModule.Specs2",
+    "com.lihaoyi" -> "TestModule.Utest",
+    "org.scalameta" -> "TestModule.Munit",
+    "com.disneystreaming" -> "TestModule.Weaver",
+    "dev.zio" -> "TestModule.ZioTest",
+    "org.scalacheck" -> "TestModule.ScalaCheck"
+  )
+
+  implicit val rw: ReadWriter[ModuleTypedef] = macroRW
+}

libs/init/migrate/api/src/mill/init/migrate/Tree.scala

@@ -0,0 +1,24 @@
+package mill.init.migrate
+
+import upickle.default.{ReadWriter, macroRW}
+
+case class Tree[+A](root: A, children: Seq[Tree[A]] = Nil) {
+
+  def iterator: Iterator[A] = Iterator(root) ++ children.iterator.flatMap(_.iterator)
+
+  def map[B](f: A => B): Tree[B] = Tree(f(root), children.map(_.map(f)))
+
+  def transform[B](f: (A, Seq[Tree[B]]) => Tree[B]): Tree[B] = f(root, children.map(_.transform(f)))
+}
+object Tree {
+
+  def gen[S, A](init: S)(step: S => (A, Seq[S])): Tree[A] = {
+    def recurse(state: S): Tree[A] = {
+      val (a, states) = step(state)
+      Tree(a, states.map(recurse))
+    }
+    recurse(init)
+  }
+
+  implicit def rw[A: ReadWriter]: ReadWriter[Tree[A]] = macroRW
+}

libs/init/migrate/package.mill

@@ -0,0 +1,43 @@
+package build.libs.init.migrate
+
+import mill.api.{Cross, PathRef, Task}
+import mill.contrib.buildinfo.BuildInfo
+import mill.scalalib.Assembly.Rule
+import mill.scalalib.ScalaModule
+import millbuild.*
+
+object `package` extends MillPublishScalaModule { migrate =>
+
+  def moduleDeps = Seq(api(Deps.scalaVersion), build.core.internal, build.libs.util)
+
+  object api extends Cross[ApiModule](Deps.sbtScalaVersion212, Deps.scalaVersion)
+  trait ApiModule extends MillPublishCrossScalaModule {
+    def mvnDeps = Seq(Deps.upickle)
+  }
+
+  object sbt extends MillPublishScalaModule with BuildInfo {
+    def moduleDeps = Seq(api(Deps.scalaVersion), migrate)
+    def sbtScriptJarResource = Task {
+      os.copy(exportscript.assembly().path, Task.dest / "exportscript-assembly.jar")
+      PathRef(Task.dest)
+    }
+    def resources = Task { super.resources() ++ Seq(sbtScriptJarResource()) }
+    def buildInfoPackageName = "mill.init.migrate.sbt"
+    def buildInfoMembers = Seq(
+      BuildInfo.Value("exportscriptAssemblyResource", "/exportscript-assembly.jar")
+    )
+
+    object api extends Cross[ApiModule](Deps.sbtScalaVersion212, Deps.scalaVersion)
+    trait ApiModule extends MillPublishCrossScalaModule {
+      def moduleDeps = Seq(migrate.api())
+    }
+
+    object exportscript extends ScalaModule {
+      def scalaVersion = Deps.sbtScalaVersion212
+      def mvnDeps = Seq(Deps.osLib)
+      def moduleDeps = Seq(api(Deps.sbtScalaVersion212))
+      def compileMvnDeps = Seq(Deps.sbt)
+      def assemblyRules = Seq(Rule.ExcludePattern("scala\\.*"))
+    }
+  }
+}

libs/init/migrate/sbt/api/src/mill/init/migrate/sbt/SbtModule.scala

@@ -0,0 +1,62 @@
+package mill.init.migrate
+package sbt
+
+import upickle.default.{ReadWriter, macroRW}
+
+case class SbtModule(
+    moduleDir: Seq[String],
+    baseDir: Seq[String],
+    platformCrossType: Option[String],
+    crossScalaVersions: Seq[String],
+    module: ModuleRepr
+)
+
+object SbtModule {
+
+  def apply(
+      moduleDir: Seq[String],
+      baseDir: Seq[String],
+      platformCrossType: Option[String],
+      crossScalaVersions: Seq[String],
+      useVersionRanges: Boolean,
+      mainConfigs: Seq[ModuleConfig],
+      testModuleName: String,
+      testModuleBase: Option[String],
+      testConfigs: Seq[ModuleConfig]
+  ): SbtModule = {
+    val isCrossPlatform = moduleDir != baseDir
+    val isCrossVersion = crossScalaVersions.length > 1
+    val layoutType =
+      if (isCrossPlatform && isCrossVersion) "CrossSbtPlatformModule"
+      else if (isCrossPlatform) "SbtPlatformModule"
+      else if (isCrossVersion) "CrossSbtModule"
+      else "SbtModule"
+    var main = if (isCrossPlatform) ModuleTypedef(baseDir.last, mainConfigs)
+    else ModuleTypedef(configs = mainConfigs)
+    main = main.extend(layoutType)
+    if (isCrossVersion && useVersionRanges) main = main.extend("CrossScalaVersionRanges")
+    val test = testModuleBase.map(testSupertype0 =>
+      ModuleTypedef(
+        testModuleName,
+        ModuleTypedef.computeTestSupertypes(main.supertypes),
+        testConfigs
+      ).extend(testSupertypeByLayout(layoutType), testSupertype0)
+    )
+    SbtModule(
+      moduleDir,
+      baseDir,
+      platformCrossType,
+      crossScalaVersions,
+      ModuleRepr(main, test)
+    )
+  }
+
+  val testSupertypeByLayout = Map(
+    "SbtModule" -> "SbtTests",
+    "CrossSbtModule" -> "CrossSbtTests",
+    "SbtPlatformModule" -> "SbtPlatformTests",
+    "CrossSbtPlatformModule" -> "CrossSbtPlatformTests"
+  )
+
+  implicit val rw: ReadWriter[SbtModule] = macroRW
+}