include only scala-library into the boot classpath during run

Fixes sbt/sbt#3405
Ref scala/scala-xml#195

sbt's `run` is emulated using a classloader trick that includes ScalaInstance as the parent classloader under the classpath. The problem is the ScalaInstance classloader currently contains both compiler, library, and their transitive JARs:

```scala
res0: Array[java.io.File] = Array(scala-library.jar, scala-compiler.jar, jline.jar, scala-reflect.jar, scala-xml_2.12.jar)
```

This could have been causing various issues, but most recently it showed up as wrong version of scala-xml getting prioritized over what's passed by the user.

Author: eed3si9n

internal/zinc-classpath/src/main/scala/sbt/internal/inc/ScalaInstance.scala

@@ -66,6 +66,11 @@ final class ScalaInstance(
     }
   }
 
+  /** ClassLoader with just scala-library.jar. */
+  lazy val libraryLoader: ClassLoader = {
+    classpath.ClasspathUtilities.toLibraryLoader(this)
+  }
+
   /** Get the string representation of all the available jars. */
   private def jarStrings: String = {
     val other = otherJars.mkString(", ")
@@ -75,6 +80,7 @@ final class ScalaInstance(
   override def toString: String =
     s"Scala instance { version label $version, actual version $actualVersion, $jarStrings }"
 }
+
 object ScalaInstance {
 
   /** Name of scala organisation to be used for artifact resolution. */

internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClasspathUtilities.scala

@@ -63,8 +63,44 @@ object ClasspathUtilities {
   final val AppClassPath = "app.class.path"
   final val BootClassPath = "boot.class.path"
 
-  def createClasspathResources(classpath: Seq[File], instance: ScalaInstance): Map[String, String] =
-    createClasspathResources(classpath, instance.allJars)
+  private[sbt] def findLibrary(instance: ScalaInstance): File = {
+    instance match {
+      case i: inc.ScalaInstance => i.libraryJar
+      case _ =>
+        (instance.allJars find { x =>
+          x.getName.startsWith("scala-library")
+        }).getOrElse {
+          throw new InvalidScalaProvider(s"Couldn't find scala-library")
+        }
+    }
+  }
+
+  /** returns the cached library loader if it's inc.ScalaInstance. */
+  def getLibraryLoader(instance: ScalaInstance): ClassLoader = {
+    instance match {
+      case i: inc.ScalaInstance => i.libraryLoader
+      case _                    => toLibraryLoader(instance)
+    }
+  }
+
+  /**
+   * Include only the scala-library.jar, if any, into the boot classpath.
+   * 1. Supposedly using boot classpath here is for performance reason:
+   *    https://groups.google.com/d/msg/scala-internals/tT1pjH5GECE/dtgRj3w7ovIJ
+   * 2. Using instance.allJars causes compiler and scala-xml (different version from cp!) to get pulled in.
+   *    https://github.com/sbt/sbt/issues/3405
+   */
+  private[sbt] def toLibraryLoader(instance: ScalaInstance): ClassLoader = {
+    val libraryJar = findLibrary(instance)
+    val cp = Vector(libraryJar)
+    toLoader(cp, rootLoader, createClasspathResources(cp, instance))
+  }
+
+  def createClasspathResources(classpath: Seq[File],
+                               instance: ScalaInstance): Map[String, String] = {
+    val libraryJar = findLibrary(instance)
+    createClasspathResources(classpath, Array(libraryJar))
+  }
 
   def createClasspathResources(appPaths: Seq[File], bootPaths: Seq[File]): Map[String, String] = {
     def make(name: String, paths: Seq[File]) = name -> Path.makeString(paths)
@@ -74,11 +110,16 @@ object ClasspathUtilities {
   private[sbt] def filterByClasspath(classpath: Seq[File], loader: ClassLoader): ClassLoader =
     new ClasspathFilter(loader, xsbtiLoader, classpath.toSet)
 
+  /**
+   * Creates a ClassLoader that contains the classpath and the scala-library from
+   * the given instance.
+   */
   def makeLoader(classpath: Seq[File], instance: ScalaInstance): ClassLoader =
-    filterByClasspath(classpath, makeLoader(classpath, instance.loader, instance))
+    filterByClasspath(classpath, makeLoader(classpath, getLibraryLoader(instance), instance))
 
   def makeLoader(classpath: Seq[File], instance: ScalaInstance, nativeTemp: File): ClassLoader =
-    filterByClasspath(classpath, makeLoader(classpath, instance.loader, instance, nativeTemp))
+    filterByClasspath(classpath,
+                      makeLoader(classpath, getLibraryLoader(instance), instance, nativeTemp))
 
   def makeLoader(classpath: Seq[File], parent: ClassLoader, instance: ScalaInstance): ClassLoader =
     toLoader(classpath, parent, createClasspathResources(classpath, instance))