diff --git a/build.sbt b/build.sbt index f223bf95f..093b9b66f 100644 --- a/build.sbt +++ b/build.sbt @@ -371,6 +371,10 @@ lazy val mainProj = (project in file("main")) // method scalaVersionFromSbtBinaryVersion(java.lang.String)java.lang.String in object sbt.Defaults does not have a correspondent in current version // Was private[sbt] ProblemFilters.exclude[DirectMissingMethodProblem]("sbt.Defaults.scalaVersionFromSbtBinaryVersion"), + // AltLibraryManagementCodec was removed. + ProblemFilters.exclude[MissingClassProblem]("sbt.internal.AltLibraryManagementCodec*"), + // The signature of internal method changed. This is ok. + ProblemFilters.exclude[IncompatibleMethTypeProblem]("sbt.internal.LibraryManagement.cachedUpdate"), ) ) .configure( diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index ad9c0a2a0..1feb05ce4 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -71,7 +71,7 @@ import scala.concurrent.duration.FiniteDuration import scala.util.control.NonFatal import scala.xml.NodeSeq import Scope.{ fillTaskAxis, GlobalScope, ThisScope } -import sjsonnew.{ IsoLList, JsonFormat, LList, LNil }, LList.:*: +import sjsonnew.{ IsoLList, JsonFormat, LList, LNil, :*: } import sjsonnew.shaded.scalajson.ast.unsafe.JValue import std.TaskExtra._ import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint } @@ -2285,16 +2285,18 @@ object Classpaths { }.value LibraryManagement.cachedUpdate( + // LM API + lm = dependencyResolution.value, + // Ivy-free ModuleDescriptor + module = ivyModule.value, s.cacheStoreFactory.sub(updateCacheName.value), Reference.display(thisProjectRef.value), - ivyModule.value, updateConf, substituteScalaFiles(scalaOrganization.value, _)(providedScalaJars), skip = (skip in update).value, force = shouldForce, depsUpdated = transitiveUpdate.value.exists(!_.stats.cached), uwConfig = (unresolvedWarningConfiguration in update).value, - depDir = Some(dependencyCacheDirectory.value), ewo = evictionOptions, mavenStyle = publishMavenStyle.value, compatWarning = compatibilityWarningOptions.value, diff --git a/main/src/main/scala/sbt/internal/AltLibraryManagementCodec.scala b/main/src/main/scala/sbt/internal/AltLibraryManagementCodec.scala deleted file mode 100644 index b66aae741..000000000 --- a/main/src/main/scala/sbt/internal/AltLibraryManagementCodec.scala +++ /dev/null @@ -1,114 +0,0 @@ -package sbt.internal - -import sbt.internal.librarymanagement._ -import sbt.internal.util.Types._ -import sbt.internal.util.{ HList, HNil } -import sbt.io.Hash -import sbt.librarymanagement._ -import sbt.librarymanagement.ivy._ -import sbt.util._ -import sbt.internal.util.HListFormats._ -import sjsonnew.JsonFormat - -object AltLibraryManagementCodec extends IvyLibraryManagementCodec { - type In0 = ModuleSettings :+: UpdateConfiguration :+: HNil - type In = IvyConfiguration :+: In0 - - object NullLogger extends sbt.internal.util.BasicLogger { - override def control(event: sbt.util.ControlEvent.Value, message: ⇒ String): Unit = () - override def log(level: Level.Value, message: ⇒ String): Unit = () - override def logAll(events: Seq[sbt.util.LogEvent]): Unit = () - override def success(message: ⇒ String): Unit = () - override def trace(t: ⇒ Throwable): Unit = () - } - - implicit val altRawRepositoryJsonFormat: JsonFormat[RawRepository] = - projectFormat(_.name, FakeRawRepository.create) - - // Redefine to add RawRepository, and switch to unionFormat - override lazy implicit val ResolverFormat: JsonFormat[Resolver] = - unionFormat8[Resolver, - ChainedResolver, - MavenRepo, - MavenCache, - FileRepository, - URLRepository, - SshRepository, - SftpRepository, - RawRepository] - - type InlineIvyHL = (Option[IvyPaths] :+: Vector[Resolver] :+: Vector[Resolver] :+: Vector[ - ModuleConfiguration] :+: Vector[String] :+: Boolean :+: HNil) - def inlineIvyToHL(i: InlineIvyConfiguration): InlineIvyHL = ( - i.paths :+: i.resolvers :+: i.otherResolvers :+: i.moduleConfigurations :+: - i.checksums :+: i.managedChecksums :+: HNil - ) - - type ExternalIvyHL = Option[PlainFileInfo] :+: Array[Byte] :+: HNil - def externalIvyToHL(e: ExternalIvyConfiguration): ExternalIvyHL = - e.baseDirectory.map(FileInfo.exists.apply) :+: e.uri - .map(Hash.contentsIfLocal) - .getOrElse(Array.empty) :+: HNil - - // Redefine to use a subset of properties, that are serialisable - override lazy implicit val InlineIvyConfigurationFormat: JsonFormat[InlineIvyConfiguration] = { - def hlToInlineIvy(i: InlineIvyHL): InlineIvyConfiguration = { - val (paths :+: resolvers :+: otherResolvers :+: moduleConfigurations :+: checksums - :+: managedChecksums :+: HNil) = i - InlineIvyConfiguration() - .withPaths(paths) - .withResolvers(resolvers) - .withOtherResolvers(otherResolvers) - .withModuleConfigurations(moduleConfigurations) - .withManagedChecksums(managedChecksums) - .withChecksums(checksums) - } - - projectFormat[InlineIvyConfiguration, InlineIvyHL](inlineIvyToHL, hlToInlineIvy) - } - - // Redefine to use a subset of properties, that are serialisable - override lazy implicit val ExternalIvyConfigurationFormat - : JsonFormat[ExternalIvyConfiguration] = { - def hlToExternalIvy(e: ExternalIvyHL): ExternalIvyConfiguration = { - val baseDirectory :+: _ /* uri */ :+: HNil = e - ExternalIvyConfiguration( - None, - Some(NullLogger), - UpdateOptions(), - baseDirectory.map(_.file), - None /* the original uri is destroyed.. */, - Vector.empty - ) - } - - projectFormat[ExternalIvyConfiguration, ExternalIvyHL](externalIvyToHL, hlToExternalIvy) - } - - // Redefine to switch to unionFormat - override implicit lazy val IvyConfigurationFormat: JsonFormat[IvyConfiguration] = - unionFormat2[IvyConfiguration, InlineIvyConfiguration, ExternalIvyConfiguration] - - def forHNil[A <: HNil]: Equiv[A] = (_: A, _: A) => true - implicit val lnilEquiv1: Equiv[HNil] = forHNil[HNil] - implicit val lnilEquiv2: Equiv[HNil.type] = forHNil[HNil.type] - - implicit def hconsEquiv[H, T <: HList](implicit he: Equiv[H], te: Equiv[T]): Equiv[H :+: T] = - (x: H :+: T, y: H :+: T) => he.equiv(x.head, y.head) && te.equiv(x.tail, y.tail) - - implicit object altIvyConfigurationEquiv extends Equiv[IvyConfiguration] { - def equiv(x: IvyConfiguration, y: IvyConfiguration): Boolean = (x, y) match { - case (x: InlineIvyConfiguration, y: InlineIvyConfiguration) => - implicitly[Equiv[InlineIvyHL]].equiv(inlineIvyToHL(x), inlineIvyToHL(y)) - case (x: ExternalIvyConfiguration, y: ExternalIvyConfiguration) => - implicitly[Equiv[ExternalIvyHL]].equiv(externalIvyToHL(x), externalIvyToHL(y)) - case (x: Any, y: Any) => sys error s"Trying to compare ${x.getClass} with ${y.getClass}" - } - } - - implicit object altInSingletonCache extends SingletonCache[In] { - def write(to: Output, value: In) = to.write(value) - def read(from: Input) = from.read[In]() - def equiv = hconsEquiv(altIvyConfigurationEquiv, implicitly[Equiv[In0]]) - } -} diff --git a/main/src/main/scala/sbt/internal/LibraryManagement.scala b/main/src/main/scala/sbt/internal/LibraryManagement.scala index 44093297b..d0a12767a 100644 --- a/main/src/main/scala/sbt/internal/LibraryManagement.scala +++ b/main/src/main/scala/sbt/internal/LibraryManagement.scala @@ -3,29 +3,25 @@ package sbt.internal import java.io.File import sbt.internal.librarymanagement._ -import sbt.internal.util.HNil -import sbt.internal.util.Types._ -import sbt.internal.util.HListFormats._ import sbt.librarymanagement._ -import sbt.librarymanagement.ivy._ import sbt.librarymanagement.syntax._ import sbt.util.{ CacheStore, CacheStoreFactory, Logger, Tracked } private[sbt] object LibraryManagement { - private type UpdateInputs = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil + private type UpdateInputs = (Long, ModuleSettings, UpdateConfiguration) def cachedUpdate( + lm: DependencyResolution, + module: ModuleDescriptor, cacheStoreFactory: CacheStoreFactory, label: String, - module: IvySbt#Module, updateConfig: UpdateConfiguration, transform: UpdateReport => UpdateReport, skip: Boolean, force: Boolean, depsUpdated: Boolean, uwConfig: UnresolvedWarningConfiguration, - depDir: Option[File], ewo: EvictionWarningOptions, mavenStyle: Boolean, compatWarning: CompatibilityWarningOptions, @@ -39,7 +35,7 @@ private[sbt] object LibraryManagement { log.info(s"Updating $label...") val reportOrUnresolved: Either[UnresolvedWarning, UpdateReport] = //try { - IvyActions.updateEither(module, updateConfig, uwConfig, /*logicalClock, depDir,*/ log) + lm.update(module, updateConfig, uwConfig, log) // } catch { // case e: Throwable => // e.printStackTrace @@ -107,18 +103,19 @@ private[sbt] object LibraryManagement { } .apply(cachedResolve(updateInputs)) } - import AltLibraryManagementCodec._ + import LibraryManagementCodec._ Tracked.inputChanged(cacheStoreFactory.make("inputs"))(doCachedResolve) } // Get the handler to use and feed it in the inputs - val ivyConfig = module.owner.configuration + // This is lm-engine specific input hashed into Long + val extraInputHash = module.extraInputHash val settings = module.moduleSettings val outStore = cacheStoreFactory.make("output") val handler = if (skip && !force) skipResolve(outStore) else doResolve(outStore) // Remove clock for caching purpose val withoutClock = updateConfig.withLogicalClock(LogicalClock.unknown) - handler(ivyConfig :+: settings :+: withoutClock :+: HNil) + handler((extraInputHash, settings, withoutClock)) } private[this] def fileUptodate(file: File, stamps: Map[File, Long]): Boolean = diff --git a/sbt/src/sbt-test/dependency-management/cache-update/build.sbt b/sbt/src/sbt-test/dependency-management/cache-update/build.sbt index 7be748a0a..b0f3eec0b 100644 --- a/sbt/src/sbt-test/dependency-management/cache-update/build.sbt +++ b/sbt/src/sbt-test/dependency-management/cache-update/build.sbt @@ -34,38 +34,33 @@ lazy val root = (project in file(".")) val cacheStoreFactory = s.cacheStoreFactory sub updateCacheName.value val module = ivyModule.value val updateConfig = updateConfiguration.value - val ivyConfiguration0 = module.owner.configuration + val extraInputHash0 = module.extraInputHash val moduleSettings0 = module.moduleSettings val inline0 = moduleSettings0 match { case x: InlineConfiguration => x } // Remove clock for caching purpose val updateConfig0 = updateConfig.withLogicalClock(LogicalClock.unknown) - import sbt.librarymanagement.ivy.IvyConfiguration - import sbt.librarymanagement.{ ModuleSettings, UpdateConfiguration } - import sbt.internal.util.HListFormats._ + import sbt.librarymanagement.{ ModuleSettings, UpdateConfiguration, LibraryManagementCodec } + type In = (Long, ModuleSettings, UpdateConfiguration) - type In = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil - - import sbt.util.CacheImplicits._ - import sbt.internal.util.HListFormats._ - import sbt.internal.AltLibraryManagementCodec._ + import LibraryManagementCodec._ val f: In => Unit = Tracked.inputChanged(cacheStoreFactory make "inputs") { (inChanged: Boolean, in: In) => - val ivyConfiguration1 = in.head - val moduleSettings1 = in.tail.head + val extraInputHash1 = in._1 + val moduleSettings1 = in._2 val inline1 = moduleSettings1 match { case x: InlineConfiguration => x } - val updateConfig1 = in.tail.tail.head + val updateConfig1 = in._3 if (inChanged) { sys.error(s""" -ivyConfiguration1 == ivyConfiguration0: ${ivyConfiguration1 == ivyConfiguration0} +extraInputHash1 == extraInputHash0: ${extraInputHash1 == extraInputHash0} -ivyConfiguration1: -$ivyConfiguration1 +extraInputHash1: +$extraInputHash1 -ivyConfiguration0 -$ivyConfiguration0 +extraInputHash0 +$extraInputHash0 ----- inline1 == inline0: ${inline1 == inline0} @@ -86,7 +81,7 @@ $updateConfig0 } } - f(ivyConfiguration0 :+: (inline0: ModuleSettings) :+: updateConfig0 :+: HNil) + f((extraInputHash0, (inline0: ModuleSettings), updateConfig0)) }, // https://github.com/sbt/sbt/issues/3226