Start to use bits of the high level API of coursier

Its parameters mostly

modules/lm-coursier/src/main/scala/coursier/lmcoursier/ArtifactsParams.scala

@@ -1,23 +1,15 @@
 package coursier.lmcoursier
 
-import java.io.File
-
 import coursier.cache.CacheLogger
-import coursier.{Cache, CachePolicy}
 import coursier.core.{Classifier, Resolution}
-
+import coursier.params.CacheParams
-import scala.concurrent.duration.Duration
 
 final case class ArtifactsParams(
   classifiers: Option[Seq[Classifier]],
   res: Seq[Resolution],
   includeSignatures: Boolean,
-  parallelDownloads: Int,
   createLogger: () => CacheLogger,
-  cache: File,
-  artifactsChecksums: Seq[Option[String]],
-  ttl: Option[Duration],
-  cachePolicies: Seq[CachePolicy],
   projectName: String,
-  sbtClassifiers: Boolean
+  sbtClassifiers: Boolean,
+  cacheParams: CacheParams
 )

modules/lm-coursier/src/main/scala/coursier/lmcoursier/ArtifactsRun.scala

@@ -39,18 +39,18 @@ object ArtifactsRun {
       val printOptionalMessage = verbosityLevel >= 0 && verbosityLevel <= 1
 
       val artifactFilesOrErrors = try {
-        pool = Schedulable.fixedThreadPool(params.parallelDownloads)
+        pool = Schedulable.fixedThreadPool(params.cacheParams.parallel)
         artifactsLogger = params.createLogger()
 
         val artifactFileOrErrorTasks = allArtifacts.toVector.distinct.map { a =>
           Cache.file[Task](
             a,
-            params.cache,
+            params.cacheParams.cacheLocation,
-            params.cachePolicies,
+            params.cacheParams.cachePolicies,
-            checksums = params.artifactsChecksums,
+            checksums = params.cacheParams.checksum,
             logger = Some(artifactsLogger),
             pool = pool,
-            ttl = params.ttl
+            ttl = params.cacheParams.ttl
           )
             .run
             .map((a, _))

modules/lm-coursier/src/main/scala/coursier/lmcoursier/CoursierDependencyResolution.scala

@@ -2,12 +2,13 @@ package coursier.lmcoursier
 
 import java.io.{File, OutputStreamWriter}
 
-import _root_.coursier.{Artifact, Cache, CachePolicy, FileError, Organization, Resolution, TermDisplay, organizationString}
+import _root_.coursier.{Artifact, CachePolicy, FileError, Organization, Resolution, TermDisplay, organizationString}
 import _root_.coursier.core.{Classifier, Configuration, ModuleName}
 import _root_.coursier.extra.Typelevel
 import _root_.coursier.ivy.IvyRepository
 import _root_.coursier.lmcoursier.Inputs.withAuthenticationByHost
 import coursier.cache.CacheDefaults
+import coursier.params.CacheParams
 import sbt.internal.librarymanagement.IvySbt
 import sbt.librarymanagement._
 import sbt.util.Logger
@@ -143,25 +144,27 @@ class CoursierDependencyResolution(conf: CoursierConfiguration) extends Dependen
       dependencies = dependencies,
       fallbackDependencies = conf.fallbackDependencies,
       configGraphs = configGraphs,
-      autoScalaLib = conf.autoScalaLibrary,
+      autoScalaLibOpt = if (conf.autoScalaLibrary) Some((so, sv)) else None,
       mainRepositories = mainRepositories,
       parentProjectCache = Map.empty,
       interProjectDependencies = conf.interProjectDependencies,
       internalRepositories = internalRepositories,
-      userEnabledProfiles = conf.mavenProfiles.toSet,
-      userForceVersions = Map.empty,
       typelevel = typelevel,
-      so = so,
-      sv = sv,
       sbtClassifiers = false,
-      parallelDownloads = conf.parallelDownloads,
       projectName = projectName,
-      maxIterations = conf.maxIterations,
       createLogger = createLogger,
-      cache = cache,
+      cacheParams = coursier.params.CacheParams(
-      cachePolicies = cachePolicies,
+        cacheLocation = cache,
-      ttl = ttl,
+        cachePolicies = cachePolicies,
-      checksums = checksums
+        ttl = ttl,
+        checksum = checksums,
+        parallel = conf.parallelDownloads
+      ),
+      params = coursier.params.ResolutionParams(
+        maxIterations = conf.maxIterations,
+        profiles = conf.mavenProfiles.toSet,
+        forceVersion = Map.empty
+      )
     )
 
     def artifactsParams(resolutions: Map[Set[Configuration], Resolution]) =
@@ -169,14 +172,16 @@ class CoursierDependencyResolution(conf: CoursierConfiguration) extends Dependen
         classifiers = classifiers,
         res = resolutions.values.toSeq,
         includeSignatures = false,
-        parallelDownloads = conf.parallelDownloads,
         createLogger = createLogger,
-        cache = cache,
-        artifactsChecksums = checksums,
-        ttl = ttl,
-        cachePolicies = cachePolicies,
         projectName = projectName,
-        sbtClassifiers = false
+        sbtClassifiers = false,
+        cacheParams = CacheParams(
+          parallel = conf.parallelDownloads,
+          cacheLocation = cache,
+          checksum = checksums,
+          ttl = ttl,
+          cachePolicies = cachePolicies
+        )
       )
 
     val sbtBootJarOverrides = SbtBootJars(

modules/lm-coursier/src/main/scala/coursier/lmcoursier/ResolutionParams.scala

@@ -1,41 +1,31 @@
 package coursier.lmcoursier
 
 import java.io.File
-import java.net.URL
 
 import coursier.cache.CacheLogger
-import coursier.{Cache, CachePolicy, FallbackDependenciesRepository, ProjectCache, Resolution, moduleNameString}
+import coursier.{FallbackDependenciesRepository, ProjectCache, Resolution, moduleNameString}
 import coursier.core._
 import coursier.extra.Typelevel
 import coursier.ivy.PropertiesPattern
 import sbt.librarymanagement.{Resolver, URLRepository}
 
 import scala.collection.mutable.ArrayBuffer
-import scala.concurrent.duration.Duration
 
 final case class ResolutionParams(
   dependencies: Seq[(Configuration, Dependency)],
   fallbackDependencies: Seq[FallbackDependency],
   configGraphs: Seq[Set[Configuration]],
-  autoScalaLib: Boolean,
+  autoScalaLibOpt: Option[(Organization, String)],
   mainRepositories: Seq[Repository],
   parentProjectCache: ProjectCache,
   interProjectDependencies: Seq[Project],
   internalRepositories: Seq[Repository],
-  userEnabledProfiles: Set[String],
-  userForceVersions: Map[Module, String],
   typelevel: Boolean,
-  so: Organization,
-  sv: String,
   sbtClassifiers: Boolean,
-  parallelDownloads: Int,
   projectName: String,
-  maxIterations: Int,
   createLogger: () => CacheLogger,
-  cache: File,
+  cacheParams: coursier.params.CacheParams,
-  cachePolicies: Seq[CachePolicy],
+  params: coursier.params.ResolutionParams
-  ttl: Option[Duration],
-  checksums: Seq[Option[String]]
 ) {
 
   val fallbackDependenciesRepositories =
@@ -79,14 +69,17 @@ final case class ResolutionParams(
       },
     filter = noOptionalFilter,
     userActivations =
-      if (userEnabledProfiles.isEmpty)
+      if (params.profiles.isEmpty)
         None
       else
-        Some(userEnabledProfiles.iterator.map(_ -> true).toMap),
+        Some(params.profiles.iterator.map(_ -> true).toMap),
     forceVersions =
       // order matters here
-      userForceVersions ++
+      params.forceVersion ++
-        (if (autoScalaLib && (configs(Configuration.compile) || configs(Configuration("scala-tool")))) forcedScalaModules(so, sv) else Map()) ++
+        autoScalaLibOpt
+          .filter(_ => configs(Configuration.compile) || configs(Configuration("scala-tool")))
+          .map { case (so, sv) => forcedScalaModules(so, sv) }
+          .getOrElse(Map.empty) ++
         interProjectDependencies.map(_.moduleVersion),
     projectCache = parentProjectCache,
     mapDependencies = if (typelevel && (configs(Configuration.compile) || configs(Configuration("scala-tool")))) typelevelOrgSwap else None
@@ -97,7 +90,7 @@ final case class ResolutionParams(
   lazy val resolutionKey = SbtCoursierCache.ResolutionKey(
     dependencies,
     repositories,
-    userEnabledProfiles,
+    params.profiles,
     allStartRes,
     sbtClassifiers
   )

modules/lm-coursier/src/main/scala/coursier/lmcoursier/ResolutionRun.scala

@@ -29,10 +29,10 @@ object ResolutionRun {
     val printOptionalMessage = verbosityLevel >= 0 && verbosityLevel <= 1
 
     val resOrError: Either[ResolutionError, Resolution] = try {
-      pool = Schedulable.fixedThreadPool(params.parallelDownloads)
+      pool = Schedulable.fixedThreadPool(params.cacheParams.parallel)
       resLogger = params.createLogger()
 
-      val fetchs = Cache.fetchs[Task](params.cache, params.cachePolicies, checksums = params.checksums, logger = Some(resLogger), pool = pool, ttl = params.ttl)
+      val fetchs = Cache.fetchs[Task](params.cacheParams.cacheLocation, params.cacheParams.cachePolicies, checksums = params.cacheParams.checksum, logger = Some(resLogger), pool = pool, ttl = params.cacheParams.ttl)
 
       val fetch = ResolutionProcess.fetch(
         params.repositories,
@@ -84,7 +84,7 @@ object ResolutionRun {
 
       startRes
         .process
-        .run(fetch, params.maxIterations)
+        .run(fetch, params.params.maxIterations)
         .attempt
         .unsafeRun()(ExecutionContext.fromExecutorService(pool))
         .left

modules/sbt-coursier/src/main/scala/coursier/sbtcoursier/ArtifactsTasks.scala

@@ -5,6 +5,7 @@ import java.io.File
 import coursier.{Artifact, FileError}
 import coursier.core._
 import coursier.lmcoursier._
+import coursier.params.CacheParams
 import coursier.sbtcoursier.Keys._
 import coursier.sbtcoursiershared.SbtCoursierShared.autoImport.{coursierCache, coursierCreateLogger}
 import sbt.Def
@@ -53,17 +54,19 @@ object ArtifactsTasks {
       val res = resTask.value
 
       val params = ArtifactsParams(
-        classifiers,
+        classifiers = classifiers,
-        res,
+        res = res,
-        includeSignatures,
+        includeSignatures = includeSignatures,
-        parallelDownloads,
+        createLogger = createLogger.create,
-        createLogger.create,
+        projectName = projectName,
-        cache,
+        sbtClassifiers = sbtClassifiers,
-        artifactsChecksums,
+        cacheParams = CacheParams(
-        ttl,
+          parallel = parallelDownloads,
-        cachePolicies,
+          cacheLocation = cache,
-        projectName,
+          checksum = artifactsChecksums,
-        sbtClassifiers
+          ttl = ttl,
+          cachePolicies = cachePolicies
+        )
       )
 
       val resOrError = ArtifactsRun.artifacts(

modules/sbt-coursier/src/main/scala/coursier/sbtcoursier/ResolutionTasks.scala

@@ -123,28 +123,30 @@ object ResolutionTasks {
 
       val resOrError = ResolutionRun.resolutions(
         ResolutionParams(
-          currentProject.dependencies,
+          dependencies = currentProject.dependencies,
-          fallbackDependencies,
+          fallbackDependencies = fallbackDependencies,
-          configGraphs,
+          configGraphs = configGraphs,
-          autoScalaLib,
+          autoScalaLibOpt = if (autoScalaLib) Some((so, sv)) else None,
-          mainRepositories,
+          mainRepositories = mainRepositories,
-          parentProjectCache,
+          parentProjectCache = parentProjectCache,
-          interProjectDependencies,
+          interProjectDependencies = interProjectDependencies,
-          internalRepositories,
+          internalRepositories = internalRepositories,
-          userEnabledProfiles,
+          typelevel = typelevel,
-          userForceVersions,
+          sbtClassifiers = sbtClassifiers,
-          typelevel,
+          projectName = projectName,
-          so,
+          createLogger = createLogger.create,
-          sv,
+          cacheParams = coursier.params.CacheParams(
-          sbtClassifiers,
+            cacheLocation = cache,
-          parallelDownloads,
+            cachePolicies = cachePolicies,
-          projectName,
+            ttl = ttl,
-          maxIterations,
+            checksum = checksums,
-          createLogger.create,
+            parallel = parallelDownloads
-          cache,
+          ),
-          cachePolicies,
+          params = coursier.params.ResolutionParams(
-          ttl,
+            maxIterations = maxIterations,
-          checksums
+            profiles = userEnabledProfiles,
+            forceVersion = userForceVersions
+          )
         ),
         verbosityLevel,
         log