Tweaking

bsp/worker/src/mill/bsp/worker/MillBuildServer.scala

@@ -337,8 +337,13 @@ private class MillBuildServer(
       tasks = { case m: JavaModule =>
         Task.Anon {
           (
-            m.compileIvyDeps(),
-            m.mandatoryIvyDeps() ++ m.ivyDeps(),
+            // full list of dependencies, including transitive ones
+            m.defaultResolver().allDeps(
+              Seq(
+                m.coursierDependency.withConfiguration(coursier.core.Configuration.provided),
+                m.coursierDependency
+              )
+            ),
             m.unmanagedClasspath()
           )
         }
@@ -349,14 +354,14 @@ private class MillBuildServer(
             state,
             id,
             m: JavaModule,
-            (compileIvyDeps, ivyDeps, unmanagedClasspath)
+            (ivyDeps, unmanagedClasspath)
           ) =>
-        val ivy = compileIvyDeps ++ ivyDeps
-        val deps = ivy.map { dep =>
-          // TODO: add data with "maven" data kind using a ...
+        val deps = ivyDeps.collect {
+          case dep if dep.module.organization != JavaModule.internalOrg =>
+            // TODO: add data with "maven" data kind using a ...
 //          MavenDependencyModule
 
-          new DependencyModule(dep.dep.module.repr, dep.dep.version)
+            new DependencyModule(dep.module.repr, dep.version)
         }
         val unmanaged = unmanagedClasspath.map { dep =>
           new DependencyModule(s"unmanaged-${dep.path.last}", "")

build.mill

@@ -590,6 +590,9 @@ trait MillStableScalaModule extends MillPublishScalaModule with Mima {
     // Overrides added for new methods, ought to be safe
     ProblemFilter.exclude[ReversedMissingMethodProblem]("mill.scalalib.JavaModule.mill$scalalib$JavaModule$$super$internalRepositories"),
     ProblemFilter.exclude[ReversedMissingMethodProblem]("mill.scalanativelib.ScalaNativeModule.mill$scalanativelib$ScalaNativeModule$$super$coursierProject"),
+    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"),
+    ProblemFilter.exclude[ReversedMissingMethodProblem]("mill.scalalib.PublishModule.mill$scalalib$PublishModule$$super$bomModuleDeps"),
 
     // https://github.com/com-lihaoyi/mill/pull/3503
     ProblemFilter.exclude[ReversedMissingMethodProblem](

docs/modules/ROOT/pages/fundamentals/library-deps.adoc

@@ -120,9 +120,9 @@ whose Maven coordinates are `com.google.cloud:libraries-bom:26.50.0`
 
 include::partial$example/fundamentals/library-deps/bom-1-external-bom.adoc[]
 
-=== Dependency management task
+=== Managed BOMs
 
-include::partial$example/fundamentals/library-deps/bom-2-dependency-management.adoc[]
+include::partial$example/fundamentals/library-deps/bom-2-managed.adoc[]
 
 == Searching For Dependency Updates
 

example/fundamentals/library-deps/bom-2-dependency-management/build.mill → example/fundamentals/library-deps/bom-2-managed/build.mill

@@ -52,3 +52,56 @@ object baz extends JavaModule {
 
 // Here, given that grpc-protobuf is fetched during dependency resolution,
 // `com.google.protobuf:protobuf-java` is excluded from it because of the dependency management.
+
+// One manage and publish BOM modules from Mill, by using `BomModule`:
+
+object myBom extends BomModule {
+  def bomIvyDeps = Agg(
+    ivy"com.google.protobuf:protobuf-bom:4.28.1"
+  )
+  def depManagement = Agg(
+    ivy"io.grpc:grpc-protobuf:1.67.1"
+  )
+}
+
+object bomUser extends JavaModule {
+  def bomModuleDeps = Seq(
+    myBom
+  )
+  def ivyDeps = Agg(
+    ivy"io.grpc:grpc-protobuf"
+  )
+}
+
+// These BOM modules can published, resulting in a Maven module with
+// packaging type `pom`, usable as a BOM from other build tools:
+
+object myPublishedBom extends BomModule with MyPublishModule {
+  def bomIvyDeps = Agg(
+    ivy"com.google.protobuf:protobuf-bom:4.28.1"
+  )
+  def depManagement = Agg(
+    ivy"io.grpc:grpc-protobuf:1.67.1"
+  )
+}
+
+object publishedBomUser extends JavaModule with MyPublishModule {
+  def bomModuleDeps = Seq(
+    myPublishedBom
+  )
+  def ivyDeps = Agg(
+    ivy"io.grpc:grpc-protobuf"
+  )
+}
+
+trait MyPublishModule extends PublishModule {
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "com.lihaoyi.mill-examples",
+    url = "https://github.com/com-lihaoyi/mill",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("com-lihaoyi", "mill"),
+    developers = Seq(Developer("me", "Me", "https://github.com/me"))
+  )
+  def publishVersion = "0.1.0"
+}

scalalib/src/mill/scalalib/CoursierModule.scala

@@ -275,6 +275,32 @@ object CoursierModule {
         )
       )
     }
+
+    /**
+     * All dependencies pulled by the passed dependencies
+     *
+     * @param deps root dependencies
+     * @return full - ordered - list of dependencies pulled by `deps`
+     */
+    def allDeps[T: CoursierModule.Resolvable](
+        deps: IterableOnce[T]
+    ): Seq[coursier.core.Dependency] = {
+      val deps0 = deps
+        .map(implicitly[CoursierModule.Resolvable[T]].bind(_, bind))
+        .iterator.toSeq
+      val res = Lib.resolveDependenciesMetadataSafe(
+        repositories = repositories,
+        deps = deps0,
+        mapDependencies = mapDependencies,
+        customizer = customizer,
+        coursierCacheCustomizer = coursierCacheCustomizer,
+        ctx = ctx,
+        resolutionParams = ResolutionParams(),
+        boms = Nil
+      ).getOrThrow
+
+      res.orderedDependencies
+    }
   }
 
   sealed trait Resolvable[T] {

scalalib/src/mill/scalalib/JavaModule.scala

@@ -479,11 +479,11 @@ trait JavaModule
     // where eval'ing a Task would be impractical or not allowed
     cs.Dependency(
       cs.Module(
-        coursier.core.Organization("mill-internal"),
+        JavaModule.internalOrg,
         coursier.core.ModuleName(millModuleSegments.parts.mkString("-")),
         Map.empty
       ),
-      "0+mill-internal"
+      JavaModule.internalVersion
     ).withConfiguration(cs.Configuration.compile)
 
   /**
@@ -533,7 +533,10 @@ trait JavaModule
           // We pull their compile scope when our compile scope is asked,
           // and pull their runtime scope when our runtime scope is asked.
           Seq(
-            (cs.Configuration.compile, modDep.coursierDependency),
+            (
+              cs.Configuration.compile,
+              modDep.coursierDependency.withConfiguration(cs.Configuration.compile)
+            ),
             (
               cs.Configuration.runtime,
               modDep.coursierDependency.withConfiguration(cs.Configuration.runtime)
@@ -543,17 +546,17 @@ trait JavaModule
         compileModuleDepsChecked.map { modDep =>
           // Compile-only (aka provided) dependencies
           // We pull their compile scope when our provided scope is asked (see scopes above)
-          (cs.Configuration.provided, modDep.coursierDependency)
+          (
+            cs.Configuration.provided,
+            modDep.coursierDependency.withConfiguration(cs.Configuration.compile)
+          )
         } ++
         runModuleDepsChecked.map { modDep =>
           // Runtime dependencies
           // We pull their runtime scope when our runtime scope is pulled
           (
             cs.Configuration.runtime,
-            modDep.coursierDependency.withConfiguration(
-              if (modDep.coursierDependency.configuration.isEmpty) cs.Configuration.runtime
-              else modDep.coursierDependency.configuration
-            )
+            modDep.coursierDependency.withConfiguration(cs.Configuration.runtime)
           )
         }
 
@@ -564,23 +567,21 @@ trait JavaModule
           // We pull their compile scope when our compile scope is asked,
           // and pull their runtime scope when our runtime scope is asked.
           Seq(
-            (cs.Configuration.compile, dep),
+            (cs.Configuration.compile, dep.withConfiguration(cs.Configuration.compile)),
             (cs.Configuration.runtime, dep.withConfiguration(cs.Configuration.runtime))
           )
       } ++
         compileIvyDeps().map(bindDependency()).map(_.dep).map { dep =>
           // Compile-only (aka provided) dependencies, like above
           // We pull their compile scope when our provided scope is asked (see scopes above)
-          (cs.Configuration.provided, dep)
+          (cs.Configuration.provided, dep.withConfiguration(cs.Configuration.compile))
         } ++
         runIvyDeps().map(bindDependency()).map(_.dep).map { dep =>
           // Runtime dependencies, like above
           // We pull their runtime scope when our runtime scope is pulled
           (
             cs.Configuration.runtime,
-            dep.withConfiguration(
-              if (dep.configuration.isEmpty) cs.Configuration.runtime else dep.configuration
-            )
+            dep.withConfiguration(cs.Configuration.runtime)
           )
         } ++
         allBomDeps().map { bomDep =>
@@ -1638,8 +1639,16 @@ object JavaModule {
       // Mill modules' artifacts are handled by Mill itself
       Nil
   }
+
+  private[mill] def internalOrg = coursier.core.Organization("mill-internal")
+  private[mill] def internalVersion = "0+mill-internal"
 }
 
+/**
+  * A module that consists solely of dependency management
+  *
+  * To be used by other modules via `JavaModule#bomModuleDeps`
+  */
 trait BomModule extends JavaModule {
   def compile: T[CompilationResult] = Task {
     val sources = allSourceFiles()

scalalib/src/mill/scalalib/PublishModule.scala

@@ -28,6 +28,14 @@ trait PublishModule extends JavaModule { outer =>
       )
   }
 
+  override def bomModuleDeps: Seq[BomModule with PublishModule] = super.bomModuleDeps.map {
+    case m: BomModule with PublishModule => m
+    case other =>
+      throw new Exception(
+        s"PublishModule bomModuleDeps need to be also PublishModules. $other is not a PublishModule"
+      )
+  }
+
   /**
    * The packaging type. See [[PackagingType]] for specially handled values.
    */

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

@@ -84,6 +84,21 @@ object Ivy {
     head + pp.format(xml).replaceAll(">", ">")
   }
 
+  // bin-compat shim
+  def apply(
+      artifact: Artifact,
+      dependencies: Agg[Dependency],
+      extras: Seq[PublishInfo],
+      overrides: Seq[Override]
+  ): String =
+    apply(
+      artifact,
+      dependencies,
+      extras,
+      overrides,
+      hasJar = true
+    )
+
   // bin-compat shim
   def apply(
       artifact: Artifact,

scalalib/src/mill/scalalib/publish/LocalIvyPublisher.scala

@@ -54,6 +54,25 @@ class LocalIvyPublisher(localIvyRepo: os.Path) {
     }
   }
 
+  // bin-compat shim
+  def publishLocal(
+      jar: os.Path,
+      sourcesJar: os.Path,
+      docJar: os.Path,
+      pom: os.Path,
+      ivy: os.Path,
+      artifact: Artifact,
+      extras: Seq[PublishInfo]
+  )(implicit ctx: Ctx.Log): Seq[os.Path] =
+    publishLocal(
+      Some(jar),
+      Some(sourcesJar),
+      Some(docJar),
+      pom,
+      Right(ivy),
+      artifact,
+      extras
+    )
 }
 
 object LocalIvyPublisher

scalalib/src/mill/scalalib/publish/LocalM2Publisher.scala

@@ -31,4 +31,21 @@ class LocalM2Publisher(m2Repo: os.Path) {
     }
   }
 
+  // bin-compat shim
+  def publish(
+      jar: os.Path,
+      sourcesJar: os.Path,
+      docJar: os.Path,
+      pom: os.Path,
+      artifact: Artifact,
+      extras: Seq[PublishInfo]
+  )(implicit ctx: Ctx.Log): Seq[os.Path] =
+    publish(
+      Some(jar),
+      Some(sourcesJar),
+      Some(docJar),
+      pom,
+      artifact,
+      extras
+    )
 }