From 55fc4a29c14db1efca482c7bc4b64568bb95b287 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Tue, 28 Oct 2014 14:28:33 -0400
Subject: [PATCH] Fixes #1699. ignore transitive force during cached resolution
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When Ivy translates pom to ivy.xml, it adds force=“true”.
So when both non-Maven dependencies and Maven dependencies are mixed, Maven dependencies always wins, which is the case for scala-library dependency added by the user.
---
 .../CachedResolutionResolveEngine.scala       | 30 ++++++++++++-------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala
index 5e7ca55e0..5654e479c 100644
--- a/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala
+++ b/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala
@@ -216,6 +216,7 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine {
   private[sbt] def cachedResolutionResolveCache: CachedResolutionResolveCache
   private[sbt] def projectResolver: Option[ProjectResolver]
   private[sbt] def makeInstance: Ivy
+  private[sbt] val ignoreTransitiveForce: Boolean = true
 
   /**
    * This returns sbt's UpdateReport structure.
@@ -339,19 +340,26 @@ private[sbt] trait CachedResolutionResolveEngine extends ResolveEngine {
       def useLatest(lcm: LatestConflictManager): (Vector[ModuleReport], Vector[ModuleReport], String) =
         (conflicts find { m =>
           m.callers.exists { _.isDirectlyForceDependency }
-        } orElse (conflicts find { m =>
-          m.callers.exists { _.isForceDependency }
-        })) match {
+        }) match {
           case Some(m) =>
-            log.debug(s"- forced dependency: $m ${m.callers}")
-            (Vector(m), conflicts filterNot { _ == m } map { _.copy(evicted = true, evictedReason = Some(lcm.toString)) }, lcm.toString)
+            log.debug(s"- directly forced dependency: $m ${m.callers}")
+            (Vector(m), conflicts filterNot { _ == m } map { _.copy(evicted = true, evictedReason = Some("direct-force")) }, "direct-force")
           case None =>
-            val strategy = lcm.getStrategy
-            val infos = conflicts map { ModuleReportArtifactInfo(_) }
-            Option(strategy.findLatest(infos.toArray, None.orNull)) match {
-              case Some(ModuleReportArtifactInfo(m)) =>
-                (Vector(m), conflicts filterNot { _ == m } map { _.copy(evicted = true, evictedReason = Some(lcm.toString)) }, lcm.toString)
-              case _ => (conflicts, Vector(), lcm.toString)
+            (conflicts find { m =>
+              m.callers.exists { _.isForceDependency }
+            }) match {
+              // Ivy translates pom.xml dependencies to forced="true", so transitive force is broken.
+              case Some(m) if !ignoreTransitiveForce =>
+                log.debug(s"- transitively forced dependency: $m ${m.callers}")
+                (Vector(m), conflicts filterNot { _ == m } map { _.copy(evicted = true, evictedReason = Some("transitive-force")) }, "transitive-force")
+              case _ =>
+                val strategy = lcm.getStrategy
+                val infos = conflicts map { ModuleReportArtifactInfo(_) }
+                Option(strategy.findLatest(infos.toArray, None.orNull)) match {
+                  case Some(ModuleReportArtifactInfo(m)) =>
+                    (Vector(m), conflicts filterNot { _ == m } map { _.copy(evicted = true, evictedReason = Some(lcm.toString)) }, lcm.toString)
+                  case _ => (conflicts, Vector(), lcm.toString)
+                }
             }
         }
       def doResolveConflict: (Vector[ModuleReport], Vector[ModuleReport], String) =