From e5ac8316a7cd511d728fbffc6c09f5b5c3133b37 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 25 Jul 2015 17:38:11 -0400 Subject: [PATCH 1/7] make sortModules tailrec --- .../sbt/ivyint/CachedResolutionResolveEngine.scala | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index 07a157107..0bf2467b8 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -407,9 +407,11 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { }: _*) val stackGuard = reports0.size * reports0.size * 2 // sort the all modules such that less called modules comes earlier - def sortModules(cs: ListMap[(String, String), Vector[OrganizationArtifactReport]], + @tailrec def sortModules(cs: ListMap[(String, String), Vector[OrganizationArtifactReport]], + acc: ListMap[(String, String), Vector[OrganizationArtifactReport]], n: Int): ListMap[(String, String), Vector[OrganizationArtifactReport]] = { + println(s"sortModules: $n / $stackGuard") val keys = cs.keySet val (called, notCalled) = cs partition { case (k, oas) => @@ -422,9 +424,8 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } } } - notCalled ++ - (if (called.isEmpty || n > stackGuard) called - else sortModules(called, n + 1)) + (if (called.isEmpty || n > stackGuard) acc ++ notCalled ++ called + else sortModules(called, acc ++ notCalled, n + 1)) } def resolveConflicts(cs: List[((String, String), Vector[OrganizationArtifactReport])]): List[OrganizationArtifactReport] = cs match { @@ -446,7 +447,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { x :: resolveConflicts(next) }) } - val sorted = sortModules(allModules, 0) + val sorted = sortModules(allModules, ListMap(), 0) val result = resolveConflicts(sorted.toList) result.toVector } From ddf941f3713a7de6985bdd2dd00f4a31a65127fe Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 25 Jul 2015 22:40:18 -0400 Subject: [PATCH 2/7] refactored to use less stack space --- .../CachedResolutionResolveEngine.scala | 97 +++++++++++-------- ivy/src/test/scala/CachedResolutionSpec.scala | 3 +- 2 files changed, 56 insertions(+), 44 deletions(-) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index 0bf2467b8..037ab4664 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -396,59 +396,68 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { def mergeOrganizationArtifactReports(rootModuleConf: String, reports0: Vector[OrganizationArtifactReport], os: Vector[IvyOverride], log: Logger): Vector[OrganizationArtifactReport] = { // group by takes up too much memory. trading space with time. - val orgNamePairs = (reports0 map { oar => (oar.organization, oar.name) }).distinct + val orgNamePairs: Vector[(String, String)] = (reports0 map { oar => (oar.organization, oar.name) }).distinct // this might take up some memory, but it's limited to a single val reports1 = reports0 map { filterOutCallers } - val allModules: ListMap[(String, String), Vector[OrganizationArtifactReport]] = - ListMap(orgNamePairs map { + val allModules0: Map[(String, String), Vector[OrganizationArtifactReport]] = + Map(orgNamePairs map { case (organization, name) => val xs = reports1 filter { oar => oar.organization == organization && oar.name == name } ((organization, name), xs) }: _*) - val stackGuard = reports0.size * reports0.size * 2 // sort the all modules such that less called modules comes earlier - @tailrec def sortModules(cs: ListMap[(String, String), Vector[OrganizationArtifactReport]], - acc: ListMap[(String, String), Vector[OrganizationArtifactReport]], - n: Int): ListMap[(String, String), Vector[OrganizationArtifactReport]] = + @tailrec def sortModules(cs: Vector[(String, String)], + acc: Vector[(String, String)], + n: Int, guard: Int): Vector[(String, String)] = { - println(s"sortModules: $n / $stackGuard") - val keys = cs.keySet - val (called, notCalled) = cs partition { - case (k, oas) => - oas exists { - _.modules.exists { - _.callers exists { caller => - val m = caller.caller - keys((m.organization, m.name)) - } + // println(s"sortModules: $n / $guard") + val keys = cs.toSet + val (called, notCalled) = cs partition { k => + val reports = allModules0(k) + reports exists { + _.modules.exists { + _.callers exists { caller => + val m = caller.caller + keys((m.organization, m.name)) } } + } } - (if (called.isEmpty || n > stackGuard) acc ++ notCalled ++ called - else sortModules(called, acc ++ notCalled, n + 1)) + lazy val result0 = acc ++ notCalled ++ called + (if (n > guard) { + log.warn(s"""cached resolution detected circular dependencies: ${cs.mkString(",")}""") + result0 + } else if (called.isEmpty || notCalled.isEmpty) result0 + else sortModules(called, acc ++ notCalled, 0, called.size * called.size + 1)) } - def resolveConflicts(cs: List[((String, String), Vector[OrganizationArtifactReport])]): List[OrganizationArtifactReport] = + def resolveConflicts(cs: List[(String, String)], + allModules: Map[(String, String), Vector[OrganizationArtifactReport]]): List[OrganizationArtifactReport] = cs match { case Nil => Nil - case (k, Vector()) :: rest => resolveConflicts(rest) - case (k, Vector(oa)) :: rest if (oa.modules.size == 0) => resolveConflicts(rest) - case (k, Vector(oa)) :: rest if (oa.modules.size == 1 && !oa.modules.head.evicted) => - log.debug(s":: no conflict $rootModuleConf: ${oa.organization}:${oa.name}") - oa :: resolveConflicts(rest) - case ((organization, name), oas) :: rest => - (mergeModuleReports(rootModuleConf, oas flatMap { _.modules }, os, log) match { - case (survivor, newlyEvicted) => - val evicted = (survivor ++ newlyEvicted) filter { m => m.evicted } - val notEvicted = (survivor ++ newlyEvicted) filter { m => !m.evicted } - log.debug("::: adds " + (notEvicted map { _.module }).mkString(", ")) - log.debug("::: evicted " + (evicted map { _.module }).mkString(", ")) - val x = new OrganizationArtifactReport(organization, name, survivor ++ newlyEvicted) - val next = transitivelyEvict(rootModuleConf, rest, evicted, log) - x :: resolveConflicts(next) - }) + case (organization, name) :: rest => + val reports = allModules((organization, name)) + reports match { + case Vector() => resolveConflicts(rest, allModules) + case Vector(oa) if (oa.modules.size == 0) => resolveConflicts(rest, allModules) + case Vector(oa) if (oa.modules.size == 1 && !oa.modules.head.evicted) => + log.debug(s":: no conflict $rootModuleConf: ${oa.organization}:${oa.name}") + oa :: resolveConflicts(rest, allModules) + case oas => + (mergeModuleReports(rootModuleConf, oas flatMap { _.modules }, os, log) match { + case (survivor, newlyEvicted) => + val evicted = (survivor ++ newlyEvicted) filter { m => m.evicted } + val notEvicted = (survivor ++ newlyEvicted) filter { m => !m.evicted } + log.debug("::: adds " + (notEvicted map { _.module }).mkString(", ")) + log.debug("::: evicted " + (evicted map { _.module }).mkString(", ")) + val x = new OrganizationArtifactReport(organization, name, survivor ++ newlyEvicted) + val nextModules = transitivelyEvict(rootModuleConf, rest, allModules, evicted, log) + x :: resolveConflicts(rest, nextModules) + }) + } } - val sorted = sortModules(allModules, ListMap(), 0) - val result = resolveConflicts(sorted.toList) + val guard0 = (orgNamePairs.size * orgNamePairs.size) + 1 + val sorted: Vector[(String, String)] = sortModules(orgNamePairs, Vector(), 0, guard0) + val result = resolveConflicts(sorted.toList, allModules0) result.toVector } def filterOutCallers(report0: OrganizationArtifactReport): OrganizationArtifactReport = @@ -491,13 +500,15 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { /** * This transitively evicts any non-evicted modules whose only callers are newly evicted. */ - def transitivelyEvict(rootModuleConf: String, reports0: List[((String, String), Vector[OrganizationArtifactReport])], - evicted0: Vector[ModuleReport], log: Logger): List[((String, String), Vector[OrganizationArtifactReport])] = + def transitivelyEvict(rootModuleConf: String, pairs: List[(String, String)], + reports0: Map[(String, String), Vector[OrganizationArtifactReport]], + evicted0: Vector[ModuleReport], log: Logger): Map[(String, String), Vector[OrganizationArtifactReport]] = { val em = (evicted0 map { _.module }).toSet def isTransitivelyEvicted(mr: ModuleReport): Boolean = mr.callers forall { c => em(c.caller) } - val reports: List[((String, String), Vector[OrganizationArtifactReport])] = reports0 map { + val reports: Seq[((String, String), Vector[OrganizationArtifactReport])] = reports0.toSeq flatMap { + case (k, v) if !(pairs contains k) => Seq() case ((organization, name), oars0) => val oars = oars0 map { oar => val (affected, unaffected) = oar.modules partition { mr => @@ -511,9 +522,9 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { if (affected.isEmpty) oar else new OrganizationArtifactReport(organization, name, unaffected ++ newlyEvicted) } - ((organization, name), oars) + Seq(((organization, name), oars)) } - reports + Map(reports: _*) } /** * resolves dependency resolution conflicts in which multiple candidates are found for organization+name combos. diff --git a/ivy/src/test/scala/CachedResolutionSpec.scala b/ivy/src/test/scala/CachedResolutionSpec.scala index 16021b15c..1860b3ed8 100644 --- a/ivy/src/test/scala/CachedResolutionSpec.scala +++ b/ivy/src/test/scala/CachedResolutionSpec.scala @@ -77,6 +77,7 @@ class CachedResolutionSpec extends BaseIvySpecification { // second resolution reads from the minigraph val report = ivyUpdate(m) val modules = report.configurations.head.modules - modules must containMatch("""org\.jboss\.netty:netty:3\.2\.0.Final""") + (modules must containMatch("""org\.jboss\.netty:netty:3\.2\.0.Final""")) and + (modules must not containMatch ("""org\.jboss\.netty:netty:3\.2\.1.Final""")) } } From 4e69d04be854205e04ae5c51e148297e8d06012b Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sun, 26 Jul 2015 23:19:16 -0400 Subject: [PATCH 3/7] try breaking circular dependency and continue sorting --- .../ivyint/CachedResolutionResolveEngine.scala | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index 037ab4664..7a9c35269 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -407,7 +407,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { }: _*) // sort the all modules such that less called modules comes earlier @tailrec def sortModules(cs: Vector[(String, String)], - acc: Vector[(String, String)], + acc: Vector[(String, String)], extra: Vector[(String, String)], n: Int, guard: Int): Vector[(String, String)] = { // println(s"sortModules: $n / $guard") @@ -423,12 +423,18 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } } } - lazy val result0 = acc ++ notCalled ++ called + lazy val result0 = acc ++ notCalled ++ called ++ extra + def warnCircular(): Unit = { + log.warn(s"""avoid circular dependency while using cached resolution: ${cs.mkString(",")}""") + } (if (n > guard) { - log.warn(s"""cached resolution detected circular dependencies: ${cs.mkString(",")}""") + warnCircular result0 - } else if (called.isEmpty || notCalled.isEmpty) result0 - else sortModules(called, acc ++ notCalled, 0, called.size * called.size + 1)) + } else if (called.isEmpty) result0 + else if (notCalled.isEmpty) { + warnCircular + sortModules(cs.tail, acc, extra :+ cs.head, n + 1, guard) + } else sortModules(called, acc ++ notCalled, extra, 0, called.size * called.size + 1)) } def resolveConflicts(cs: List[(String, String)], allModules: Map[(String, String), Vector[OrganizationArtifactReport]]): List[OrganizationArtifactReport] = @@ -456,7 +462,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } } val guard0 = (orgNamePairs.size * orgNamePairs.size) + 1 - val sorted: Vector[(String, String)] = sortModules(orgNamePairs, Vector(), 0, guard0) + val sorted: Vector[(String, String)] = sortModules(orgNamePairs, Vector(), Vector(), 0, guard0) val result = resolveConflicts(sorted.toList, allModules0) result.toVector } From 71faf889163044931a07e45b17ae6ccc59ef4cfd Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 3 Aug 2015 07:31:32 -0400 Subject: [PATCH 4/7] Fixes #2129. break up circular dependency loops in cached resolution Simple remove-one method to workaround for circular dependency did not work. This fix traverses the entire graph to detect all loops and then breaks them up. --- .../CachedResolutionResolveEngine.scala | 75 ++++++++++++++++++- 1 file changed, 73 insertions(+), 2 deletions(-) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index 7a9c35269..bae20ec75 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -405,6 +405,77 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { val xs = reports1 filter { oar => oar.organization == organization && oar.name == name } ((organization, name), xs) }: _*) + // this returns a List of Lists of (org, name). should be deterministic + def detectLoops(allModules: Map[(String, String), Vector[OrganizationArtifactReport]]): List[List[(String, String)]] = + { + val loopSets: mutable.Set[Set[(String, String)]] = mutable.Set.empty + val loopLists: mutable.ListBuffer[List[(String, String)]] = mutable.ListBuffer.empty + def testLoop(m: (String, String), current: (String, String), history: List[(String, String)]): Unit = + { + val callers = + (for { + oar <- allModules.getOrElse(current, Vector()) + mr <- oar.modules + c <- mr.callers + } yield (c.caller.organization, c.caller.name)).distinct + callers foreach { c => + if (history contains c) { + val loop = (c :: history.takeWhile(_ != c)) ::: List(c) + if (!loopSets(loop.toSet)) { + loopSets += loop.toSet + loopLists += loop + val loopStr = (loop map { case (o, n) => s"$o:$n" }).mkString("->") + log.warn(s"""avoid circular dependency while using cached resolution: $loopStr""") + } + } else testLoop(m, c, c :: history) + } + } + orgNamePairs map { orgname => + testLoop(orgname, orgname, List(orgname)) + } + loopLists.toList + } + @tailrec def breakLoops(loops: List[List[(String, String)]], + allModules1: Map[(String, String), Vector[OrganizationArtifactReport]]): Map[(String, String), Vector[OrganizationArtifactReport]] = + loops match { + case Nil => + allModules1 + case loop :: rest => + loop match { + case Nil => + breakLoops(rest, allModules1) + case loop => + val sortedLoop = loop sortBy { x => + (for { + oar <- allModules0(x) + mr <- oar.modules + c <- mr.callers + } yield c).size + } + val moduleWithMostCallers = sortedLoop.reverse.head + val next: (String, String) = loop(loop.indexOf(moduleWithMostCallers) + 1) + // remove the module with most callers as the caller of next. + // so, A -> C, B -> C, and C -> A. C has the most callers, and C -> A will be removed. + val nextMap = allModules1 map { + case (k: (String, String), oars0) if k == next => + val oars: Vector[OrganizationArtifactReport] = oars0 map { oar => + val mrs = oar.modules map { mr => + val callers0 = mr.callers + val callers = callers0 filterNot { c => (c.caller.organization, c.caller.name) == moduleWithMostCallers } + if (callers.size == callers0.size) mr + else mr.copy(callers = callers) + } + OrganizationArtifactReport(oar.organization, oar.name, mrs) + } + (k, oars) + case (k, v) => (k, v) + } + breakLoops(rest, nextMap) + } + } + val loop = detectLoops(allModules0) + log.debug(s":: $rootModuleConf: loop: $loop") + val allModules2 = breakLoops(loop, allModules0) // sort the all modules such that less called modules comes earlier @tailrec def sortModules(cs: Vector[(String, String)], acc: Vector[(String, String)], extra: Vector[(String, String)], @@ -413,7 +484,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { // println(s"sortModules: $n / $guard") val keys = cs.toSet val (called, notCalled) = cs partition { k => - val reports = allModules0(k) + val reports = allModules2(k) reports exists { _.modules.exists { _.callers exists { caller => @@ -425,7 +496,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } lazy val result0 = acc ++ notCalled ++ called ++ extra def warnCircular(): Unit = { - log.warn(s"""avoid circular dependency while using cached resolution: ${cs.mkString(",")}""") + log.warn(s"""unexpected circular dependency while using cached resolution: ${cs.mkString(",")}""") } (if (n > guard) { warnCircular From fb2ccdd285eb324fa7e25b94c0636019dc0effdc Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 3 Aug 2015 08:17:48 -0400 Subject: [PATCH 5/7] Add debug logs --- .../scala/sbt/ivyint/CachedResolutionResolveEngine.scala | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index bae20ec75..73b0ec6fc 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -463,7 +463,10 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { val callers0 = mr.callers val callers = callers0 filterNot { c => (c.caller.organization, c.caller.name) == moduleWithMostCallers } if (callers.size == callers0.size) mr - else mr.copy(callers = callers) + else { + log.debug(s":: $rootModuleConf: removing caller $moduleWithMostCallers -> $next for sorting") + mr.copy(callers = callers) + } } OrganizationArtifactReport(oar.organization, oar.name, mrs) } @@ -534,6 +537,8 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } val guard0 = (orgNamePairs.size * orgNamePairs.size) + 1 val sorted: Vector[(String, String)] = sortModules(orgNamePairs, Vector(), Vector(), 0, guard0) + val sortedStr = (sorted map { case (o, n) => s"$o:$n" }).mkString(", ") + log.debug(s":: sort result: $sortedStr") val result = resolveConflicts(sorted.toList, allModules0) result.toVector } From 6848fd9f69474fde2181907ee9cb53940ad0d957 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Wed, 5 Aug 2015 07:00:39 -0400 Subject: [PATCH 6/7] cached resolution: don't include callers from evicted modules --- .../sbt/ivyint/CachedResolutionResolveEngine.scala | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index 73b0ec6fc..96c7d88b4 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -395,6 +395,18 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { */ def mergeOrganizationArtifactReports(rootModuleConf: String, reports0: Vector[OrganizationArtifactReport], os: Vector[IvyOverride], log: Logger): Vector[OrganizationArtifactReport] = { + // filter out evicted modules from further logic + def filterReports(report0: OrganizationArtifactReport): Option[OrganizationArtifactReport] = + report0.modules.toVector flatMap { mr => + if (mr.evicted || mr.problem.nonEmpty) None + else + // https://github.com/sbt/sbt/issues/1763 + Some(mr.copy(callers = JsonUtil.filterOutArtificialCallers(mr.callers))) + } match { + case Vector() => None + case ms => Some(OrganizationArtifactReport(report0.organization, report0.name, ms)) + } + // group by takes up too much memory. trading space with time. val orgNamePairs: Vector[(String, String)] = (reports0 map { oar => (oar.organization, oar.name) }).distinct // this might take up some memory, but it's limited to a single From 2264a1052c542748c46c17ba06383323f3c84f0a Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Wed, 5 Aug 2015 07:01:21 -0400 Subject: [PATCH 7/7] cached resolution: use mutable map to speed up breakLoops --- .../CachedResolutionResolveEngine.scala | 32 ++++++++----------- 1 file changed, 13 insertions(+), 19 deletions(-) diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala index 96c7d88b4..4ff745276 100644 --- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala +++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala @@ -410,7 +410,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { // group by takes up too much memory. trading space with time. val orgNamePairs: Vector[(String, String)] = (reports0 map { oar => (oar.organization, oar.name) }).distinct // this might take up some memory, but it's limited to a single - val reports1 = reports0 map { filterOutCallers } + val reports1 = reports0 flatMap { filterReports } val allModules0: Map[(String, String), Vector[OrganizationArtifactReport]] = Map(orgNamePairs map { case (organization, name) => @@ -447,15 +447,15 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } loopLists.toList } - @tailrec def breakLoops(loops: List[List[(String, String)]], - allModules1: Map[(String, String), Vector[OrganizationArtifactReport]]): Map[(String, String), Vector[OrganizationArtifactReport]] = + val allModules2: mutable.Map[(String, String), Vector[OrganizationArtifactReport]] = + mutable.Map(allModules0.toSeq: _*) + @tailrec def breakLoops(loops: List[List[(String, String)]]): Unit = loops match { - case Nil => - allModules1 + case Nil => () case loop :: rest => loop match { case Nil => - breakLoops(rest, allModules1) + breakLoops(rest) case loop => val sortedLoop = loop sortBy { x => (for { @@ -468,7 +468,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { val next: (String, String) = loop(loop.indexOf(moduleWithMostCallers) + 1) // remove the module with most callers as the caller of next. // so, A -> C, B -> C, and C -> A. C has the most callers, and C -> A will be removed. - val nextMap = allModules1 map { + allModules2 foreach { case (k: (String, String), oars0) if k == next => val oars: Vector[OrganizationArtifactReport] = oars0 map { oar => val mrs = oar.modules map { mr => @@ -482,15 +482,17 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { } OrganizationArtifactReport(oar.organization, oar.name, mrs) } - (k, oars) - case (k, v) => (k, v) + allModules2(k) = oars + case (k, v) => // do nothing } - breakLoops(rest, nextMap) + + breakLoops(rest) } } val loop = detectLoops(allModules0) log.debug(s":: $rootModuleConf: loop: $loop") - val allModules2 = breakLoops(loop, allModules0) + breakLoops(loop) + // sort the all modules such that less called modules comes earlier @tailrec def sortModules(cs: Vector[(String, String)], acc: Vector[(String, String)], extra: Vector[(String, String)], @@ -554,14 +556,6 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine { val result = resolveConflicts(sorted.toList, allModules0) result.toVector } - def filterOutCallers(report0: OrganizationArtifactReport): OrganizationArtifactReport = - OrganizationArtifactReport( - report0.organization, - report0.name, - report0.modules map { mr => - // https://github.com/sbt/sbt/issues/1763 - mr.copy(callers = JsonUtil.filterOutArtificialCallers(mr.callers)) - }) /** * Merges ModuleReports, which represents orgnization, name, and version. * Returns a touple of (surviving modules ++ non-conflicting modules, newly evicted modules).