Add BOM support for compileIvyDeps, runIvyDeps, and BOM test dependencies

build.mill

@@ -551,6 +551,9 @@ trait MillStableScalaModule extends MillPublishScalaModule with Mima {
     ProblemFilter.exclude[ReversedMissingMethodProblem](
       "mill.scalalib.JavaModule.mill$scalalib$JavaModule$$super$runMain"
     ),
+    // Added overrides for a new targets, should be safe
+    ProblemFilter.exclude[ReversedMissingMethodProblem]("mill.scalalib.JavaModule#JavaModuleTests.mill$scalalib$JavaModule$JavaModuleTests$$super$extraBomIvyDeps"),
+    ProblemFilter.exclude[ReversedMissingMethodProblem]("mill.scalalib.JavaModule#JavaModuleTests.mill$scalalib$JavaModule$JavaModuleTests$$super$extraDepManagement"),
     // Terminal is sealed, not sure why MIMA still complains
     ProblemFilter.exclude[ReversedMissingMethodProblem]("mill.eval.Terminal.task"),
 

scalalib/src/mill/scalalib/JavaModule.scala

@@ -57,6 +57,15 @@ trait JavaModule
       }
     }
 
+    override def extraBomIvyDeps = Task.Anon[Agg[BomDependency]] {
+      super.extraBomIvyDeps() ++
+        outer.allBomIvyDeps().map(_.withConfig(Configuration.test))
+    }
+    override def extraDepManagement = Task.Anon[Agg[Dep]] {
+      super.extraDepManagement() ++
+        outer.depManagement()
+    }
+
     /**
      * JavaModule and its derivatives define inner test modules.
      * To avoid unexpected misbehavior due to the use of the wrong inner test trait
@@ -165,7 +174,7 @@ trait JavaModule
    */
   def bomIvyDeps: T[Agg[Dep]] = Task { Agg.empty[Dep] }
 
-  def allBomDeps: Task[Agg[BomDependency]] = Task.Anon {
+  def allBomIvyDeps: Task[Agg[BomDependency]] = Task.Anon {
     val modVerOrMalformed =
       bomIvyDeps().map(bindDependency()).map { bomDep =>
         val fromModVer = coursier.core.Dependency(bomDep.dep.module, bomDep.dep.version)
@@ -191,6 +200,23 @@ trait JavaModule
       )
   }
 
+  /**
+   * BOM dependencies that are not meant to be overridden or changed by users.
+   *
+   * This is mainly used to add BOM dependencies of the main module to its test
+   * modules, while ensuring test dependencies of the BOM are taken into account too
+   * in the test module.
+   */
+  def extraBomIvyDeps: Task[Agg[BomDependency]] = Task.Anon { Agg.empty[BomDependency] }
+
+  /**
+   * Dependency management entries that are not meant to be overridden or changed by users.
+   *
+   * This is mainly used to add dependency management entries of the main module to its test
+   * modules.
+   */
+  def extraDepManagement: Task[Agg[Dep]] = Task.Anon { Agg.empty[Dep] }
+
   /**
    * Dependency management data
    *
@@ -206,9 +232,32 @@ trait JavaModule
    *     ivy"com.lihaoyi::cask:0.9.4".exclude("org.slf4j", "slf4j-api")
    *   )
    * }}}
+   *
+   * Versions and exclusions specified here apply to dependencies pulled via
+   * `ivyDeps`, `compileIvyDeps` (compile-only or "provided" dependencies), and
+   * `runIvyDeps` (runtime dependencies).
    */
   def depManagement: T[Agg[Dep]] = Task { Agg.empty[Dep] }
 
+  /**
+   * Dependency management data for the compile only or "provided" scope.
+   *
+   * Versions and exclusions specified here apply only to dependencies pulled via
+   * `compileIvyDeps`.
+   */
+  def compileDepManagement: T[Agg[Dep]] = Task { Agg.empty[Dep] }
+
+  /**
+   * Dependency management data for the runtime scope.
+   *
+   * Versions and exclusions specified here apply only to dependencies pulled via
+   * `runIvyDeps`.
+   *
+   * @param overrideVersions Whether versions in BOMs should override those of the passed
+   *                         dependencies themselves
+   */
+  def runDepManagement: T[Agg[Dep]] = Task { Agg.empty[Dep] }
+
   private def addBoms(
       bomIvyDeps: Seq[coursier.core.BomDependency],
       depMgmt: Seq[(DependencyManagement.Key, DependencyManagement.Values)],
@@ -455,13 +504,62 @@ trait JavaModule
   /**
    * Returns a function adding BOM and dependency management details of
    * this module to a `coursier.core.Dependency`
+   *
+   * Meant to be called on values originating from `ivyDeps`
    */
   def processDependency(
       overrideVersions: Boolean = false
   ): Task[coursier.core.Dependency => coursier.core.Dependency] = Task.Anon {
-    val bomDeps0 = allBomDeps().toSeq.map(_.withConfig(Configuration.compile))
+    val bomDeps0 =
+      allBomIvyDeps().toSeq.map(_.withConfig(Configuration.compile)) ++ extraBomIvyDeps().toSeq
+    val depMgmt = processedDependencyManagement(
+      (extraDepManagement().toSeq ++ depManagement().toSeq)
+        .map(bindDependency())
+        .map(_.dep)
+    )
+
+    addBoms(bomDeps0, depMgmt, overrideVersions = overrideVersions)
+  }
+
+  /**
+   * Returns a function adding BOM and dependency management details of
+   * this module to a `coursier.core.Dependency`
+   *
+   * Meant to be called on values originating from `compileIvyDeps`
+   *
+   * @param overrideVersions Whether versions in BOMs should override those of the passed
+   *                         dependencies themselves
+   */
+  def processCompileDependency(
+      overrideVersions: Boolean = false
+  ): Task[coursier.core.Dependency => coursier.core.Dependency] = Task.Anon {
+    val bomDeps0 = allBomIvyDeps().toSeq.map(_.withConfig(Configuration.provided))
     val depMgmt = processedDependencyManagement(
-      depManagement().toSeq.map(bindDependency()).map(_.dep)
+      (compileDepManagement().toSeq ++ extraDepManagement().toSeq ++ depManagement().toSeq)
+        .map(bindDependency())
+        .map(_.dep)
+    )
+
+    addBoms(bomDeps0, depMgmt, overrideVersions = overrideVersions)
+  }
+
+  /**
+   * Returns a function adding BOM and dependency management details of
+   * this module to a `coursier.core.Dependency`
+   *
+   * Meant to be called on values originating from `runIvyDeps`
+   *
+   * @param overrideVersions Whether versions in BOMs should override those of the passed
+   *                         dependencies themselves
+   */
+  def processRunDependency(
+      overrideVersions: Boolean = false
+  ): Task[coursier.core.Dependency => coursier.core.Dependency] = Task.Anon {
+    val bomDeps0 = allBomIvyDeps().toSeq.map(_.withConfig(Configuration.defaultCompile))
+    val depMgmt = processedDependencyManagement(
+      (runDepManagement().toSeq ++ depManagement())
+        .map(bindDependency())
+        .map(_.dep)
     )
 
     addBoms(bomDeps0, depMgmt, overrideVersions = overrideVersions)
@@ -479,11 +577,38 @@ trait JavaModule
     }
   }
 
+  /**
+   * The compile-time Ivy dependencies of this module, with BOM and dependency management details
+   * added to them. This should be used when propagating the dependencies transitively
+   * to other modules.
+   */
+  def processedCompileIvyDeps: Task[Agg[BoundDep]] = Task.Anon {
+    val processDependency0 = processCompileDependency()()
+    compileIvyDeps().map(bindDependency()).map { dep =>
+      dep.copy(dep = processDependency0(dep.dep))
+    }
+  }
+
+  /**
+   * The runtime Ivy dependencies of this module, with BOM and dependency management details
+   * added to them. This should be used when propagating the dependencies transitively
+   * to other modules.
+   */
+  def processedRunIvyDeps: Task[Agg[BoundDep]] = Task.Anon {
+    val processDependency0 = processRunDependency()()
+    runIvyDeps().map(bindDependency()).map { dep =>
+      dep.copy(dep = processDependency0(dep.dep))
+    }
+  }
+
   /**
    * The transitive ivy dependencies of this module and all it's upstream modules.
    * This is calculated from [[ivyDeps]], [[mandatoryIvyDeps]] and recursively from [[moduleDeps]].
    */
   def transitiveIvyDeps: T[Agg[BoundDep]] = Task {
+    // overrideVersions is true for dependencies originating from moduleDeps,
+    // as these are transitive (the direct dependency is the one in moduleDeps),
+    // so versions in BOMs should override their versions
     val processDependency0 = processDependency(overrideVersions = true)()
     processedIvyDeps() ++
       T.traverse(moduleDepsChecked)(_.transitiveIvyDeps)().flatten.map { dep =>
@@ -493,20 +618,35 @@ trait JavaModule
 
   /** The compile-only transitive ivy dependencies of this module and all it's upstream compile-only modules. */
   def transitiveCompileIvyDeps: T[Agg[BoundDep]] = Task {
+    // overrideVersions is true for dependencies originating from moduleDeps,
+    // as these are transitive (the direct dependency is the one in moduleDeps),
+    // so versions in BOMs should override their versions
+    val processDependency0 = processCompileDependency(overrideVersions = true)()
     // We never include compile-only dependencies transitively, but we must include normal transitive dependencies!
-    compileIvyDeps().map(bindDependency()) ++
-      T.traverse(compileModuleDepsChecked)(_.transitiveIvyDeps)().flatten
+    processedCompileIvyDeps() ++
+      T.traverse(compileModuleDepsChecked)(_.transitiveIvyDeps)().flatten.map { dep =>
+        dep.copy(dep = processDependency0(dep.dep))
+      }
   }
 
   /**
    * The transitive run ivy dependencies of this module and all it's upstream modules.
    * This is calculated from [[runIvyDeps]], [[mandatoryIvyDeps]] and recursively from [[moduleDeps]].
    */
   def transitiveRunIvyDeps: T[Agg[BoundDep]] = Task {
-    runIvyDeps().map(bindDependency()) ++
-      T.traverse(moduleDepsChecked)(_.transitiveRunIvyDeps)().flatten ++
-      T.traverse(runModuleDepsChecked)(_.transitiveIvyDeps)().flatten ++
-      T.traverse(runModuleDepsChecked)(_.transitiveRunIvyDeps)().flatten
+    // overrideVersions is true for dependencies originating from moduleDeps,
+    // as these are transitive (the direct dependency is the one in moduleDeps),
+    // so versions in BOMs should override their versions
+    val processDependency0 = processRunDependency(overrideVersions = true)()
+    processedRunIvyDeps() ++ {
+      val viaModules =
+        T.traverse(moduleDepsChecked)(_.transitiveRunIvyDeps)().flatten ++
+          T.traverse(runModuleDepsChecked)(_.transitiveIvyDeps)().flatten ++
+          T.traverse(runModuleDepsChecked)(_.transitiveRunIvyDeps)().flatten
+      viaModules.map { dep =>
+        dep.copy(dep = processDependency0(dep.dep))
+      }
+    }
   }
 
   /**

scalalib/src/mill/scalalib/PublishModule.scala

@@ -111,7 +111,14 @@ trait PublishModule extends JavaModule { outer =>
    * Dependency management to specify in the POM
    */
   def publishXmlDepMgmt: Task[Agg[Dependency]] = Task.Anon {
-    depManagement().map(resolvePublishDependency.apply().apply(_))
+    (extraDepManagement() ++ depManagement())
+      .map(resolvePublishDependency.apply().apply(_)) ++
+      compileDepManagement()
+        .map(resolvePublishDependency.apply().apply(_))
+        .map(_.copy(scope = Scope.Provided)) ++
+      runDepManagement()
+        .map(resolvePublishDependency.apply().apply(_))
+        .map(_.copy(scope = Scope.Runtime))
   }
 
   def pom: T[PathRef] = Task {
@@ -137,9 +144,10 @@ trait PublishModule extends JavaModule { outer =>
   def bomDetails: T[(Map[coursier.core.Module, String], coursier.core.DependencyManagement.Map)] =
     Task {
       val (processedDeps, depMgmt) = defaultResolver().processDeps(
-        processedIvyDeps(),
+        processedRunIvyDeps() ++ processedIvyDeps(),
         resolutionParams = resolutionParams(),
-        boms = allBomDeps().toSeq.map(_.withConfig(Configuration.compile))
+        boms = allBomIvyDeps().toSeq.map(_.withConfig(Configuration.defaultCompile)) ++
+          extraBomIvyDeps().toSeq
       )
       (processedDeps.map(_.moduleVersion).toMap, depMgmt)
     }
@@ -163,24 +171,57 @@ trait PublishModule extends JavaModule { outer =>
       else
         dep
     }
+    val bomDepMgmt0 = {
+      // Ensure we don't override versions of root dependencies with overrides from the BOM
+      val rootDepsAdjustment = publishXmlDeps0.iterator.flatMap { dep =>
+        val key = coursier.core.DependencyManagement.Key(
+          coursier.core.Organization(dep.artifact.group),
+          coursier.core.ModuleName(dep.artifact.id),
+          coursier.core.Type.jar,
+          coursier.core.Classifier.empty
+        )
+        bomDepMgmt.get(key).flatMap { values =>
+          if (values.version.nonEmpty && values.version != dep.artifact.version)
+            Some(key -> values.withVersion(""))
+          else
+            None
+        }
+      }
+      bomDepMgmt ++ rootDepsAdjustment
+    }
+    lazy val moduleSet = publishXmlDeps0.map(dep => (dep.artifact.group, dep.artifact.id)).toSet
     val overrides = {
       val depMgmtEntries = processedDependencyManagement(
-        depManagement().toSeq
+        (extraDepManagement().toSeq ++ depManagement().toSeq)
           .map(bindDependency())
           .map(_.dep)
           .filter(_.version.nonEmpty)
+          .filter { depMgmt =>
+            // Ensure we don't override versions of root dependencies with overrides from the BOM
+            !moduleSet.contains((depMgmt.module.organization.value, depMgmt.module.name.value))
+          }
       )
       val entries = coursier.core.DependencyManagement.add(
         Map.empty,
-        depMgmtEntries ++ bomDepMgmt
+        depMgmtEntries ++ bomDepMgmt0
+          .filter {
+            case (key, _) =>
+              // Ensure we don't override versions of root dependencies with overrides from the BOM
+              !moduleSet.contains((key.organization.value, key.name.value))
+          }
       )
       entries.toVector
         .map {
           case (key, values) =>
+            val confString =
+              // we pull the runtime dependency of runtime dependencies, like Maven does
+              if (values.config == Configuration.runtime) "runtime->runtime"
+              else ""
             Ivy.Override(
               key.organization.value,
               key.name.value,
-              values.version
+              values.version,
+              confString
             )
         }
         .sortBy(value => (value.organization, value.name, value.version))

scalalib/src/mill/scalalib/publish/Ivy.scala

@@ -8,7 +8,7 @@ object Ivy {
 
   val head = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 
-  case class Override(organization: String, name: String, version: String)
+  case class Override(organization: String, name: String, version: String, confString: String)
 
   def apply(
       artifact: Artifact,
@@ -89,7 +89,11 @@ object Ivy {
   }
 
   private def renderOverride(override0: Override): Elem =
-    <override org={override0.organization} module={override0.name} rev={override0.version} />
+    if (override0.confString.isEmpty)
+      <override org={override0.organization} module={override0.name} rev={override0.version} />
+    else
+      <override org={override0.organization} module={override0.name} rev={override0.version}
+        conf={override0.confString} />
 
   private def depIvyConf(d: Dependency): String = {
     def target(value: String) = d.configuration.getOrElse(value)