Prefer defaultResolver().classpath over Lib.resolveDependencies (#4727)

Whenever possible, this tries to make modules defined in Mill use
`CoursierModule#defaultResolver` or `CoursierModule#millResolver` to
resolve dependencies, rather than calling lower level helpers like `Lib.
resolveDependencies`. The former automatically take into account
customizations of resolution defined on `CoursierModule` and
`JavaModule` (`repositoriesTask`, `mapDependencies`, etc.), while these
have to be passed manually to `Lib.resolveDependencies`.

This helps when adding more parameters - these have to be passed to
`defaultResolver` / `millResolver`, and that's it, rather than also
having to inspect all calls to `Lib.resolveDependencies`, and passing
the new parameter there too.

This also tries to make resolution log to the task logger of the task
requesting the resolution, rather than the logger of
`CoursierModule#{defaultResolver,millResolver}`.

Pull request: #4727

Author: alexarchambault

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

@@ -293,7 +293,7 @@ private class MillBuildServer(
         case m: JavaModule =>
           Task.Anon {
             (
-              m.millResolver().resolveDeps(
+              m.millResolver().classpath(
                 Seq(
                   m.coursierDependency.withConfiguration(coursier.core.Configuration.provided),
                   m.coursierDependency
@@ -337,12 +337,14 @@ private class MillBuildServer(
         Task.Anon {
           (
             // full list of dependencies, including transitive ones
-            m.millResolver().allDeps(
-              Seq(
-                m.coursierDependency.withConfiguration(coursier.core.Configuration.provided),
-                m.coursierDependency
+            m.millResolver()
+              .resolution(
+                Seq(
+                  m.coursierDependency.withConfiguration(coursier.core.Configuration.provided),
+                  m.coursierDependency
+                )
               )
-            ),
+              .orderedDependencies,
             m.unmanagedClasspath()
           )
         }

ci/mill-bootstrap.patch

@@ -136,6 +136,20 @@ index 92bfb2c2f8f..9854c30dac1 100644
  }
 
  trait MillPublishCrossScalaModule extends MillPublishJavaModule with CrossScalaModule
+@@ -746,10 +747,10 @@ trait BridgeModule extends MillPublishCrossScalaModule {
+   )
+
+   def compilerBridgeSourceJars: T[Agg[PathRef]] = Task {
+-    resolveDeps(
+-      Task.Anon { compilerBridgeIvyDeps().map(bindDependency()) },
++    defaultResolver().classpath(
++      compilerBridgeIvyDeps(),
+       sources = true
+-    )()
++    )
+   }
+
+   def generatedSources = Task {
 diff --git a/contrib/package.mill b/contrib/package.mill
 index b68c27a1ef8..01a3e9da2c0 100644
 --- a/contrib/package.mill
@@ -596,12 +610,22 @@ diff --git a/main/package.mill b/main/package.mill
 index 73c8cd24f9c..362eac814cd 100644
 --- a/main/package.mill
 +++ b/main/package.mill
-@@ -80,7 +80,7 @@ object `package` extends RootModule with build.MillStableScalaModule with BuildI
-           Some(Task.ctx()),
-           dist.coursierCacheCustomizer()
+@@ -75,15 +75,10 @@ object `package` extends RootModule with build.MillStableScalaModule with BuildI
+           }
+         }().toMap
+ 
+-        val result = Lib.resolveDependenciesMetadataSafe(
+-          repositories = dist.allRepositories(),
+-          Seq(BoundDep(dist.coursierDependency, force = false)),
+-          Some(dist.mapDependencies()),
+-          dist.resolutionCustomizer(),
+-          Some(Task.ctx()),
+-          dist.coursierCacheCustomizer()
++        val result = dist.millResolver().resolution(
++          Seq(BoundDep(dist.coursierDependency, force = false))
          )
 -        result.getOrThrow.orderedDependencies
-+        result.get.orderedDependencies
++        result.orderedDependencies
            .map(dep => s"${dep.module.repr}:${dep.version}")
            .distinct
            .map(mod => internalToPublishedModuleMap.getOrElse(mod, mod))

contrib/bloop/src/mill/contrib/bloop/BloopImpl.scala

@@ -377,7 +377,7 @@ class BloopImpl(
 
     val millBuildDependencies: Task[List[BloopConfig.Module]] = Task.Anon {
 
-      val result = module.defaultResolver().getArtifacts(
+      val result = module.defaultResolver().artifacts(
         BuildInfo.millAllDistDependencies
           .split(',')
           .filter(_.nonEmpty)

contrib/flyway/src/mill/contrib/flyway/FlywayModule.scala

@@ -29,7 +29,7 @@ trait FlywayModule extends JavaModule {
   def flywayDriverDeps: T[Seq[Dep]]
 
   def jdbcClasspath = Task {
-    defaultResolver().resolveDeps(flywayDriverDeps())
+    defaultResolver().classpath(flywayDriverDeps())
   }
 
   private def strToOptPair[A](key: String, v: String) =

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

@@ -104,7 +104,7 @@ trait JmhModule extends JavaModule {
     }
 
   def generatorDeps = Task {
-    defaultResolver().resolveDeps(
+    defaultResolver().classpath(
       Seq(ivy"org.openjdk.jmh:jmh-generator-bytecode:${jmhGeneratorByteCodeVersion()}")
     )
   }

contrib/playlib/src/mill/playlib/RouterModule.scala

@@ -46,7 +46,7 @@ trait RouterModule extends ScalaModule with Version {
   def generatorType: RouteCompilerType = RouteCompilerType.InjectedGenerator
 
   def routerClasspath: T[Seq[PathRef]] = Task {
-    defaultResolver().resolveDeps(
+    defaultResolver().classpath(
       playMinorVersion() match {
         case "2.6" | "2.7" | "2.8" =>
           Seq(ivy"com.typesafe.play::routes-compiler:${playVersion()}")

contrib/playlib/src/mill/playlib/Static.scala

@@ -5,7 +5,7 @@ import java.nio.file._
 import java.nio.file.attribute.BasicFileAttributes
 import java.util
 
-import mill.scalalib.{Lib, ScalaModule}
+import mill.scalalib.ScalaModule
 import mill.{PathRef, Task}
 
 trait Static extends ScalaModule {
@@ -49,15 +49,13 @@ trait Static extends ScalaModule {
   def webJarDeps = Task {
     ivyDeps()
       .filter(_.dep.module.organization.value == "org.webjars")
-      .map(bindDependency())
   }
 
   /**
    * jar files of web jars
    */
   def webJars = Task {
-    Lib.resolveDependencies(
-      repositoriesTask(),
+    defaultResolver().classpath(
       webJarDeps()
     )
   }

contrib/proguard/src/mill/contrib/proguard/Proguard.scala

@@ -121,7 +121,7 @@ trait Proguard extends ScalaModule {
    * The location of the proguard jar files.
    */
   def proguardClasspath: T[Seq[PathRef]] = Task {
-    defaultResolver().resolveDeps(Seq(
+    defaultResolver().classpath(Seq(
       ivy"com.guardsquare:proguard-base:${proguardVersion()}"
     ))
   }

contrib/scalapblib/src/mill/contrib/scalapblib/ScalaPBModule.scala

@@ -3,7 +3,6 @@ package contrib.scalapblib
 
 import coursier.core.Version
 import mill.api.{PathRef}
-import mill.scalalib.Lib.resolveDependencies
 import mill.scalalib._
 
 import java.util.zip.ZipInputStream
@@ -76,10 +75,11 @@ trait ScalaPBModule extends ScalaModule {
   }
 
   def scalaPBClasspath: T[Seq[PathRef]] = Task {
-    resolveDependencies(
-      repositoriesTask(),
+    val scalaPBScalaVersion = "2.13.1"
+    defaultResolver().classpath(
       Seq(ivy"com.thesamet.scalapb::scalapbc:${scalaPBVersion()}")
-        .map(Lib.depToBoundDep(_, "2.13.1"))
+        .map(Lib.depToBoundDep(_, scalaPBScalaVersion)),
+      resolutionParamsMapOpt = Some(_.withScalaVersion(scalaPBScalaVersion))
     )
   }
 
@@ -91,7 +91,7 @@ trait ScalaPBModule extends ScalaModule {
   }
 
   def scalaPBProtoClasspath: T[Agg[PathRef]] = Task {
-    millResolver().resolveDeps(
+    millResolver().classpath(
       Seq(
         coursierDependency.withConfiguration(coursier.core.Configuration.provided),
         coursierDependency

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

@@ -113,11 +113,11 @@ trait ScoverageModule extends ScalaModule { outer: ScalaModule =>
 
   def scoverageToolsClasspath: T[Seq[PathRef]] = Task {
     scoverageReportWorkerClasspath() ++
-      defaultResolver().resolveDeps(scoverageReporterIvyDeps())
+      defaultResolver().classpath(scoverageReporterIvyDeps())
   }
 
   def scoverageClasspath: T[Seq[PathRef]] = Task {
-    defaultResolver().resolveDeps(scoveragePluginDeps())
+    defaultResolver().classpath(scoveragePluginDeps())
   }
 
   def scoverageReportWorkerClasspath: T[Seq[PathRef]] = Task {
@@ -209,7 +209,7 @@ trait ScoverageModule extends ScalaModule { outer: ScalaModule =>
       val outerScoverageClassesPath = outer.scoverage.compile().classes
       (super.runClasspath().map { path =>
         if (outerClassesPath == path) outerScoverageClassesPath else path
-      } ++ defaultResolver().resolveDeps(outer.scoverageRuntimeDeps())).distinct
+      } ++ defaultResolver().classpath(outer.scoverageRuntimeDeps())).distinct
     }
   }
 }