Merge the sbt compiler bridge in a subdirectory

This merges the branch move-subdirectory of
github.com/smarter/dotty-bridge which was created using:
git filter-branch --tree-filter 'mkdir .bridge && mv * .bridge &&
 mv .bridge bridge'

This commit does not update the dotty Build.scala to also build the
dotty-bridge, this will be done by the next commit.

Author: smarter

bridge/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2015-2016 The dotty-bridge contributors.
+All rights reserved.
+
+Some parts of this project are copied or adapted from sbt which is:
+Copyright (c) 2008-2016 Typesafe Inc, Mark Harrah, Grzegorz Kossakowski,
+Josh Suereth, Indrajit Raychaudhuri, Eugene Yokota, and other contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

bridge/README.md

@@ -0,0 +1,21 @@
+## dotty-bridge
+
+### Overview
+
+This is an sbt compiler bridge for [Dotty](https://github.com/lampepfl/dotty),
+it allows you to compile your code using Dotty instead of Scala 2.
+
+### Implementation status
+
+- [X] `sbt compile` support, including [incremental recompilation](http://www.scala-sbt.org/0.13/docs/Understanding-Recompilation.html)
+- [ ] `sbt console` support (may involve some changes to the Dotty REPL)
+- [ ] `sbt doc` support
+
+### Usage
+
+See https://github.com/smarter/dotty-example-project for an example.
+
+### Discuss
+
+Feel free to come chat with us on the
+[Dotty gitter](http://gitter.im/lampepfl/dotty)!

bridge/build.sbt

@@ -0,0 +1,54 @@
+lazy val root = (project in file(".")).
+  settings(
+    organization := "ch.epfl.lamp",
+    name := "dotty-bridge",
+    description := "sbt compiler bridge for Dotty",
+    resolvers += Resolver.typesafeIvyRepo("releases"),
+    libraryDependencies := Seq(
+      "ch.epfl.lamp" %% "dotty" % "0.1-SNAPSHOT",
+      "org.scala-sbt" % "interface" % sbtVersion.value,
+      "org.scala-sbt" % "api" % sbtVersion.value % "test",
+      "org.specs2" %% "specs2" % "2.3.11" % "test"
+    ),
+    publishArtifact in packageDoc := false,
+    version := "0.1.1-SNAPSHOT",
+    // 2.11.5 is the version used by Dotty itself currently, we do the same to
+    // avoid trouble.
+    scalaVersion := "2.11.5",
+    // Ideally, the sources should be published with crossPaths := false and the
+    // binaries with crossPaths := true, but I haven't figured out how to do this.
+    crossPaths := false,
+
+    fork in Test := true,
+    parallelExecution in Test := false
+  )
+
+// Options for scripted tests
+ScriptedPlugin.scriptedSettings
+scriptedLaunchOpts := Seq("-Xmx1024m")
+scriptedBufferLog := false
+// TODO: Use this instead of manually copying DottyInjectedPlugin.scala
+// everywhere once https://github.com/sbt/sbt/issues/2601 gets fixed.
+/*
+scriptedPrescripted := { f =>
+  IO.write(inj, """
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := "0.1-SNAPSHOT",
+    scalaOrganization := "ch.epfl.lamp",
+    scalacOptions += "-language:Scala2",
+    scalaBinaryVersion  := "2.11",
+    autoScalaLibrary := false,
+    libraryDependencies ++= Seq("org.scala-lang" % "scala-library" % "2.11.5"),
+    scalaCompilerBridgeSource := ("ch.epfl.lamp" % "dotty-bridge" % "0.1.1-SNAPSHOT" % "component").sources()
+  )
+}
+""")
+}
+*/

bridge/project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.11

bridge/project/scripted.sbt

@@ -0,0 +1,3 @@
+libraryDependencies <+= (sbtVersion) { sv =>
+  "org.scala-sbt" % "scripted-plugin" % sv
+}

bridge/src/main/scala/xsbt/CompilerClassLoader.scala

@@ -0,0 +1,90 @@
+package xsbt
+
+import java.net.{URL, URLClassLoader}
+
+/**  A classloader to run the compiler
+ *
+ *   A CompilerClassLoader is constructed from a list of `urls` that need to be on
+ *   the classpath to run the compiler and the classloader used by sbt.
+ *
+ *   To understand why a custom classloader is needed for the compiler, let us
+ *   describe some alternatives that wouldn't work.
+ *   - `new URLClassLoader(urls)`:
+ *     The compiler contains sbt phases that callback to sbt using the `xsbti.*`
+ *     interfaces. If `urls` does not contain the sbt interfaces we'll get a
+ *     `ClassNotFoundException` in the compiler when we try to use them, if
+ *     `urls` does contain the interfaces we'll get a `ClassCastException` or a
+ *     `LinkageError` because if the same class is loaded by two different
+ *     classloaders, they are considered distinct by the JVM.
+ *    - `new URLClassLoader(urls, sbtLoader)`:
+ *      Because of the JVM delegation model, this means that we will only load
+ *      a class from `urls` if it's not present in the parent `sbtLoader`, but
+ *      sbt uses its own version of the scala compiler and scala library which
+ *      is not the one we need to run the compiler.
+ *
+ *  Our solution is to implement a subclass of URLClassLoader with no parent, instead
+ *  we override `loadClass` to load the `xsbti.*` interfaces from `sbtLoader`.
+ */
+class CompilerClassLoader(urls: Array[URL], sbtLoader: ClassLoader)
+    extends URLClassLoader(urls, null) {
+  override def loadClass(className: String, resolve: Boolean): Class[_] =
+    if (className.startsWith("xsbti.")) {
+      // We can't use the loadClass overload with two arguments because it's
+      // protected, but we can do the same by hand (the classloader instance
+      // from which we call resolveClass does not matter).
+      val c = sbtLoader.loadClass(className)
+      if (resolve)
+        resolveClass(c)
+      c
+    } else {
+      super.loadClass(className, resolve)
+    }
+}
+
+object CompilerClassLoader {
+  /** Fix the compiler bridge ClassLoader
+   *
+   *  Soundtrack: https://www.youtube.com/watch?v=imamcajBEJs
+   *
+   *  The classloader that we get from sbt looks like:
+   *
+   *    URLClassLoader(bridgeURLs,
+   *      DualLoader(scalaLoader, notXsbtiFilter, sbtLoader, xsbtiFilter))
+   *
+   *  DualLoader will load the `xsbti.*` interfaces using `sbtLoader` and
+   *  everything else with `scalaLoader`. Once we have loaded the dotty Main
+   *  class using `scalaLoader`, subsequent classes in the dotty compiler will
+   *  also be loaded by `scalaLoader` and _not_ by the DualLoader. But the sbt
+   *  compiler phases are part of dotty and still need access to the `xsbti.*`
+   *  interfaces in `sbtLoader`, therefore DualLoader does not work for us
+   *  (this issue is not present with scalac because the sbt phases are
+   *  currently defined in the compiler bridge itself, not in scalac).
+   *
+   *  CompilerClassLoader is a replacement for DualLoader. Until we can fix
+   *  this in sbt proper, we need to use reflection to construct our own
+   *  fixed classloader:
+   *
+   *    URLClassLoader(bridgeURLs,
+   *      CompilerClassLoader(scalaLoader.getURLs, sbtLoader))
+   *
+   *  @param bridgeLoader  The classloader that sbt uses to load the compiler bridge
+   *  @return A fixed classloader that works with dotty
+   */
+  def fixBridgeLoader(bridgeLoader: ClassLoader) = bridgeLoader match {
+    case bridgeLoader: URLClassLoader =>
+      val dualLoader = bridgeLoader.getParent
+      val dualLoaderClass = dualLoader.getClass
+
+      // DualLoader#parentA and DualLoader#parentB are private
+      val parentAField = dualLoaderClass.getDeclaredField("parentA")
+      parentAField.setAccessible(true)
+      val parentBField = dualLoaderClass.getDeclaredField("parentB")
+      parentBField.setAccessible(true)
+      val scalaLoader = parentAField.get(dualLoader).asInstanceOf[URLClassLoader]
+      val sbtLoader = parentBField.get(dualLoader).asInstanceOf[URLClassLoader]
+
+      val bridgeURLs = bridgeLoader.getURLs
+      new URLClassLoader(bridgeURLs,
+        new CompilerClassLoader(scalaLoader.getURLs, sbtLoader))
+  }
+}

bridge/src/main/scala/xsbt/CompilerInterface.scala

@@ -0,0 +1,70 @@
+/* sbt -- Simple Build Tool
+ * Copyright 2008, 2009 Mark Harrah
+ */
+package xsbt
+
+import xsbti.{ AnalysisCallback, Logger, Problem, Reporter, Severity, DependencyContext }
+import xsbti.api.SourceAPI
+import xsbti.compile._
+import Log.debug
+import java.io.File
+
+import dotty.tools.dotc.core.Contexts.ContextBase
+import dotty.tools.dotc.{ Main => DottyMain }
+import dotty.tools.dotc.interfaces._
+
+import java.net.URLClassLoader
+
+final class CompilerInterface {
+  def newCompiler(options: Array[String], output: Output, initialLog: Logger,
+                  initialDelegate: Reporter, resident: Boolean): CachedCompiler = {
+    // The classloader that sbt uses to load the compiler bridge is broken
+    // (see CompilerClassLoader#fixBridgeLoader for details). To workaround
+    // this we construct our own ClassLoader and then run the following code
+    // with it:
+    //   new CachedCompilerImpl(options, output, resident)
+
+    val bridgeLoader = getClass.getClassLoader
+    val fixedLoader = CompilerClassLoader.fixBridgeLoader(bridgeLoader)
+    val cciClass = fixedLoader.loadClass("xsbt.CachedCompilerImpl")
+    cciClass.getConstructors.head
+      .newInstance(options, output, resident: java.lang.Boolean)
+      .asInstanceOf[CachedCompiler]
+  }
+
+  def run(sources: Array[File], changes: DependencyChanges, callback: AnalysisCallback, log: Logger,
+          delegate: Reporter, progress: CompileProgress, cached: CachedCompiler): Unit =
+    cached.run(sources, changes, callback, log, delegate, progress)
+}
+
+class CachedCompilerImpl(args: Array[String], output: Output, resident: Boolean) extends CachedCompiler {
+  val outputArgs =
+    output match {
+      case multi: MultipleOutput =>
+        ???
+      case single: SingleOutput =>
+        List("-d", single.outputDirectory.getAbsolutePath.toString)
+    }
+
+  def commandArguments(sources: Array[File]): Array[String] =
+    (outputArgs ++ args.toList ++ sources.map(_.getAbsolutePath).sortWith(_ < _)).toArray[String]
+
+  def run(sources: Array[File], changes: DependencyChanges, callback: AnalysisCallback, log: Logger, delegate: Reporter, progress: CompileProgress): Unit = synchronized {
+    run(sources.toList, changes, callback, log, progress)
+  }
+  private[this] def run(sources: List[File], changes: DependencyChanges, callback: AnalysisCallback, log: Logger, compileProgress: CompileProgress): Unit = {
+    debug(log, args.mkString("Calling Dotty compiler with arguments  (CompilerInterface):\n\t", "\n\t", ""))
+    val ctx = (new ContextBase).initialCtx.fresh
+      .setSbtCallback(callback)
+    val cl = getClass.getClassLoader.asInstanceOf[URLClassLoader]
+
+    val reporter = DottyMain.process(commandArguments(sources.toArray), ctx)
+    if (reporter.hasErrors) {
+      throw new InterfaceCompileFailed(args, Array())
+    }
+  }
+}
+
+class InterfaceCompileFailed(override val arguments: Array[String], override val problems: Array[Problem]) extends xsbti.CompileFailed {
+  override val toString = "Compilation failed"
+}

bridge/src/main/scala/xsbt/Log.scala

@@ -0,0 +1,10 @@
+/* sbt -- Simple Build Tool
+ * Copyright 2008, 2009 Mark Harrah
+ */
+package xsbt
+
+object Log {
+  def debug(log: xsbti.Logger, msg: => String) = log.debug(Message(msg))
+  def settingsError(log: xsbti.Logger): String => Unit =
+    s => log.error(Message(s))
+}

bridge/src/main/scala/xsbt/Message.scala

@@ -0,0 +1,8 @@
+/* sbt -- Simple Build Tool
+ * Copyright 2008, 2009 Mark Harrah
+ */
+package xsbt
+
+object Message {
+  def apply[T](s: => T) = new xsbti.F0[T] { def apply() = s }
+}

bridge/src/sbt-test/source-dependencies/abstract-override/A.scala

@@ -0,0 +1,3 @@
+trait A {
+	def x: Int
+}

bridge/src/sbt-test/source-dependencies/abstract-override/B.scala

@@ -0,0 +1,3 @@
+trait B extends A {
+	override def x = 2
+}

bridge/src/sbt-test/source-dependencies/abstract-override/C.scala

@@ -0,0 +1,3 @@
+trait C extends A {
+	def x = 5
+}

bridge/src/sbt-test/source-dependencies/abstract-override/D.scala

@@ -0,0 +1 @@
+trait D extends C with B

bridge/src/sbt-test/source-dependencies/abstract-override/changes/C2.scala

@@ -0,0 +1,3 @@
+trait C extends A {
+	abstract override def x = super.x + 5
+}

bridge/src/sbt-test/source-dependencies/abstract-override/project/DottyInjectedPlugin.scala

@@ -0,0 +1,17 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := "0.1-SNAPSHOT",
+    scalaOrganization := "ch.epfl.lamp",
+    scalacOptions += "-language:Scala2",
+    scalaBinaryVersion  := "2.11",
+    autoScalaLibrary := false,
+    libraryDependencies ++= Seq("org.scala-lang" % "scala-library" % "2.11.5"),
+    scalaCompilerBridgeSource := ("ch.epfl.lamp" % "dotty-bridge" % "0.1.1-SNAPSHOT" % "component").sources()
+  )
+}

bridge/src/sbt-test/source-dependencies/abstract-override/test

@@ -0,0 +1,3 @@
+> compile
+$ copy-file changes/C2.scala C.scala
+-> compile

bridge/src/sbt-test/source-dependencies/abstract-type-override/build.sbt

@@ -0,0 +1,7 @@
+InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) =>
+  (argTask, compile in Compile) map { (args: Seq[String], a: sbt.inc.Analysis) =>
+    assert(args.size == 1)
+    val expectedIterationsNumber = args(0).toInt
+    assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))
+  }
+}

bridge/src/sbt-test/source-dependencies/abstract-type-override/changes/Bar1.scala

@@ -0,0 +1,4 @@
+object Bar {
+  def bar: Outer.TypeInner = null
+  // comment to trigger recompilation
+}

bridge/src/sbt-test/source-dependencies/abstract-type-override/project/DottyInjectedPlugin.scala

@@ -0,0 +1,17 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := "0.1-SNAPSHOT",
+    scalaOrganization := "ch.epfl.lamp",
+    scalacOptions += "-language:Scala2",
+    scalaBinaryVersion  := "2.11",
+    autoScalaLibrary := false,
+    libraryDependencies ++= Seq("org.scala-lang" % "scala-library" % "2.11.5"),
+    scalaCompilerBridgeSource := ("ch.epfl.lamp" % "dotty-bridge" % "0.1.1-SNAPSHOT" % "component").sources()
+  )
+}

bridge/src/sbt-test/source-dependencies/abstract-type-override/src/main/scala/Bar.scala

@@ -0,0 +1,3 @@
+object Bar {
+  def bar: Outer.TypeInner = null
+}

bridge/src/sbt-test/source-dependencies/abstract-type-override/src/main/scala/Foo.scala

@@ -0,0 +1,5 @@
+object Outer {
+  class Inner { type Xyz }
+
+  type TypeInner = Inner { type Xyz = Int }
+}

bridge/src/sbt-test/source-dependencies/abstract-type-override/src/main/scala/Impl.scala

@@ -0,0 +1,3 @@
+class Impl {
+  def bleep = Bar.bar
+}