18 files changed, 298 insertions, 93 deletions
diff --git a/.gitignore b/.gitignore
index 9842e0c6b..170cf4823 100644
--- a/.gitignore
+++ b/.gitignore
@@ -44,6 +44,7 @@ scala-scala
 out/
 build/
 !out/.keep
+testlogs/
 
 # Ignore build-file
 .packages
diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index f8267072e..0e8ae196a 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -103,7 +103,7 @@ object Decorators {
      *  as long as `xs`.
      */
     def zipWithConserve[U](ys: List[U])(f: (T, U) => T): List[T] =
-      if (xs.isEmpty) xs
+      if (xs.isEmpty || ys.isEmpty) Nil
       else {
         val x1 = f(xs.head, ys.head)
         val xs1 = xs.tail.zipWithConserve(ys.tail)(f)
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index bc140c26b..e0b233ce8 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -661,7 +661,7 @@ class ClassfileParser(
     for (entry <- innerClasses.values) {
       // create a new class member for immediate inner classes
       if (entry.outerName == currentClassName) {
-        val file = ctx.platform.classPath.findSourceFile(entry.externalName.toString) getOrElse {
+        val file = ctx.platform.classPath.findBinaryFile(entry.externalName.toString) getOrElse {
           throw new AssertionError(entry.externalName)
         }
         enterClassAndModule(entry, file, entry.jflags)
diff --git a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala
index 17eb8d39b..91e65ab66 100644
--- a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala
@@ -21,7 +21,7 @@ trait MessageRendering {
     * @return string stripped of ANSI escape codes
     */
   def stripColor(str: String): String =
-    str.replaceAll("\u001B\\[[;\\d]*m", "")
+    str.replaceAll("\u001b\\[.*?m", "")
 
   /** When inlining a method call, if there's an error we'd like to get the
     * outer context and the `pos` at which the call was inlined.
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 7576ccc05..b0ae36612 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -848,13 +848,14 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       val nextBinder = afterTest.asTerm
 
-      def needsOuterTest(patType: Type, selType: Type, currentOwner: Symbol): Boolean = {
+      def outerTestNeeded(implicit ctx: Context): Boolean = {
         // See the test for SI-7214 for motivation for dealias. Later `treeCondStrategy#outerTest`
         // generates an outer test based on `patType.prefix` with automatically dealises.
-        patType.dealias match {
-          case tref @ TypeRef(pre, name) =>
-            (pre ne NoPrefix) && tref.symbol.isClass &&
-            ExplicitOuter.needsOuterIfReferenced(tref.symbol.asClass)
+        expectedTp.dealias match {
+          case tref @ TypeRef(pre: SingletonType, name) =>
+            val s = tref
+            s.symbol.isClass &&
+            ExplicitOuter.needsOuterIfReferenced(s.symbol.asClass)
           case _ =>
             false
         }
@@ -862,12 +863,6 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       override lazy val introducedRebindings = NoRebindings
 
-      def outerTestNeeded = {
-        val np = expectedTp.normalizedPrefix
-        val ts = np.termSymbol
-        (ts ne NoSymbol) && needsOuterTest(expectedTp, testedBinder.info, ctx.owner)
-      }
-
       // the logic to generate the run-time test that follows from the fact that
       // a `prevBinder` is expected to have type `expectedTp`
       // the actual tree-generation logic is factored out, since the analyses generate Cond(ition)s rather than Trees
diff --git a/compiler/src/dotty/tools/dotc/util/DiffUtil.scala b/compiler/src/dotty/tools/dotc/util/DiffUtil.scala
index b55aee719..6f7df13a6 100644
--- a/compiler/src/dotty/tools/dotc/util/DiffUtil.scala
+++ b/compiler/src/dotty/tools/dotc/util/DiffUtil.scala
@@ -58,8 +58,25 @@ object DiffUtil {
     (fnd, exp, totalChange.toDouble / (expected.length + found.length))
   }
 
-  def mkColoredCodeDiff(code: String, lastCode: String, printDiffDel: Boolean): String = {
+  def mkColoredLineDiff(expected: String, actual: String): String = {
+    val tokens = splitTokens(expected, Nil).toArray
+    val lastTokens = splitTokens(actual, Nil).toArray
+
+    val diff = hirschberg(lastTokens, tokens)
 
+    "  |SOF\n" + diff.collect {
+      case Unmodified(str) =>
+        "  |" + str
+      case Inserted(str) =>
+        ADDITION_COLOR + "e |" + str + ANSI_DEFAULT
+      case Modified(old, str) =>
+        DELETION_COLOR + "a |" + old + "\ne |" + ADDITION_COLOR + str + ANSI_DEFAULT
+      case Deleted(str) =>
+        DELETION_COLOR + "\na |" + str + ANSI_DEFAULT
+    }.mkString + "\n  |EOF"
+  }
+
+  def mkColoredCodeDiff(code: String, lastCode: String, printDiffDel: Boolean): String = {
     val tokens = splitTokens(code, Nil).toArray
     val lastTokens = splitTokens(lastCode, Nil).toArray
 
diff --git a/compiler/src/dotty/tools/io/ClassPath.scala b/compiler/src/dotty/tools/io/ClassPath.scala
index 3afbed838..5e77c1b61 100644
--- a/compiler/src/dotty/tools/io/ClassPath.scala
+++ b/compiler/src/dotty/tools/io/ClassPath.scala
@@ -240,22 +240,16 @@ abstract class ClassPath {
   def findClass(name: String): Option[AnyClassRep] =
     name.splitWhere(_ == '.', doDropIndex = true) match {
       case Some((pkg, rest)) =>
-        val rep = packages find (_.name == pkg) flatMap (_ findClass rest)
-        rep map {
-          case x: ClassRep  => x
-          case x            => throw new FatalError("Unexpected ClassRep '%s' found searching for name '%s'".format(x, name))
-        }
+        packages find (_.name == pkg) flatMap (_ findClass rest)
       case _ =>
         classes find (_.name == name)
     }
 
-  def findSourceFile(name: String): Option[AbstractFile] =
-    findClass(name) match {
-      case Some(ClassRep(Some(x: AbstractFile), _)) => Some(x)
-      case _                                        => None
-    }
+  def findBinaryFile(name: String): Option[AbstractFile] =
+    findClass(name).flatMap(_.binary)
 
   def sortString = join(split(asClasspathString).sorted: _*)
+
   override def equals(that: Any) = that match {
     case x: ClassPath => this.sortString == x.sortString
     case _            => false
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 788e30aa3..742b93fae 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -12,7 +12,7 @@ import scala.util.matching.Regex
 class CompilationTests extends ParallelSummaryReport with ParallelTesting {
   import CompilationTests._
 
-  def isInteractive: Boolean = !sys.env.contains("DRONE")
+  def isInteractive: Boolean = ParallelSummaryReport.isInteractive
 
   def testFilter: Option[Regex] = sys.props.get("dotty.partest.filter").map(r => new Regex(r))
 
diff --git a/compiler/test/dotty/tools/dotc/ParallelSummaryReport.java b/compiler/test/dotty/tools/dotc/ParallelSummaryReport.java
index 9214e7d25..5608b3656 100644
--- a/compiler/test/dotty/tools/dotc/ParallelSummaryReport.java
+++ b/compiler/test/dotty/tools/dotc/ParallelSummaryReport.java
@@ -11,7 +11,9 @@ import dotty.tools.dotc.reporting.TestReporter$;
  *  this class
  */
 public class ParallelSummaryReport {
-    private static TestReporter rep = TestReporter.reporter(-1);
+    public final static boolean isInteractive = !System.getenv().containsKey("DRONE");
+
+    private static TestReporter rep = TestReporter.reporter(System.out, -1);
     private static ArrayDeque<String> failedTests = new ArrayDeque<>();
     private static ArrayDeque<String> reproduceInstructions = new ArrayDeque<>();
     private static int passed;
@@ -34,7 +36,7 @@ public class ParallelSummaryReport {
     }
 
     @BeforeClass public final static void setup() {
-        rep = TestReporter.reporter(-1);
+        rep = TestReporter.reporter(System.out, -1);
         failedTests = new ArrayDeque<>();
         reproduceInstructions = new ArrayDeque<>();
     }
@@ -54,7 +56,8 @@ public class ParallelSummaryReport {
             .map(x -> "    " + x)
             .forEach(rep::echo);
 
-        rep.flushToStdErr();
+        // If we're compiling locally, we don't need reproduce instructions
+        if (isInteractive) rep.flushToStdErr();
 
         rep.echo("");
 
@@ -62,6 +65,9 @@ public class ParallelSummaryReport {
             .stream()
             .forEach(rep::echo);
 
+        // If we're on the CI, we want everything
+        if (!isInteractive) rep.flushToStdErr();
+
         if (failed > 0) rep.flushToFile();
     }
 }
diff --git a/compiler/test/dotty/tools/dotc/ParallelTesting.scala b/compiler/test/dotty/tools/dotc/ParallelTesting.scala
index 289351d81..2b20887e3 100644
--- a/compiler/test/dotty/tools/dotc/ParallelTesting.scala
+++ b/compiler/test/dotty/tools/dotc/ParallelTesting.scala
@@ -51,6 +51,16 @@ trait ParallelTesting { self =>
     def outDir: JFile
     def flags: Array[String]
 
+
+    def title: String = self match {
+      case self: JointCompilationSource =>
+        if (self.files.length > 1) name
+        else self.files.head.getPath
+
+      case self: SeparateCompilationSource =>
+        self.dir.getPath
+    }
+
     /** Adds the flags specified in `newFlags0` if they do not already exist */
     def withFlags(newFlags0: String*) = {
       val newFlags = newFlags0.toArray
@@ -69,7 +79,11 @@ trait ParallelTesting { self =>
       val maxLen = 80
       var lineLen = 0
 
-      sb.append(s"\n\nTest compiled with $errors error(s) and $warnings warning(s), the test can be reproduced by running:")
+      sb.append(
+        s"""|
+            |Test '$title' compiled with $errors error(s) and $warnings warning(s),
+            |the test can be reproduced by running:""".stripMargin
+      )
       sb.append("\n\n./bin/dotc ")
       flags.foreach { arg =>
         if (lineLen > maxLen) {
@@ -160,6 +174,8 @@ trait ParallelTesting { self =>
    *  according to the implementing class "neg", "run" or "pos".
    */
   private abstract class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean) {
+    protected final val realStdout = System.out
+    protected final val realStderr = System.err
 
     /** Actual compilation run logic, the test behaviour is defined here */
     protected def compilationRunnable(testSource: TestSource): Runnable
@@ -178,10 +194,10 @@ trait ParallelTesting { self =>
     val sourceCount = filteredSources.length
 
     private[this] var _errorCount =  0
-    def errorCount: Int = synchronized { _errorCount }
+    def errorCount: Int = _errorCount
 
     private[this] var _testSourcesCompiled = 0
-    private def testSourcesCompiled : Int = synchronized { _testSourcesCompiled }
+    private def testSourcesCompiled: Int = _testSourcesCompiled
 
     /** Complete the current compilation with the amount of errors encountered */
     protected final def registerCompilation(errors: Int) = synchronized {
@@ -214,7 +230,7 @@ trait ParallelTesting { self =>
 
     /** Prints to `System.err` if we're not suppressing all output */
     protected def echo(msg: String): Unit =
-      if (!suppressAllOutput) System.err.println(msg)
+      if (!suppressAllOutput) realStderr.println(msg)
 
     /** A single `Runnable` that prints a progress bar for the curent `Test` */
     private def createProgressMonitor: Runnable = new Runnable {
@@ -224,17 +240,19 @@ trait ParallelTesting { self =>
         while (tCompiled < sourceCount) {
           val timestamp = (System.currentTimeMillis - start) / 1000
           val progress = (tCompiled.toDouble / sourceCount * 40).toInt
-          print(
+
+          realStdout.print(
             "[" + ("=" * (math.max(progress - 1, 0))) +
             (if (progress > 0) ">" else "") +
             (" " * (39 - progress)) +
             s"] compiling ($tCompiled/$sourceCount, ${timestamp}s)\r"
           )
+
           Thread.sleep(100)
           tCompiled = testSourcesCompiled
         }
         // println, otherwise no newline and cursor at start of line
-        println(
+        realStdout.println(
           s"[=======================================] compiled ($sourceCount/$sourceCount, " +
           s"${(System.currentTimeMillis - start) / 1000}s)  "
         )
@@ -245,7 +263,10 @@ trait ParallelTesting { self =>
      *  if it did, the test should automatically fail.
      */
     protected def tryCompile(testSource: TestSource)(op: => Unit): Unit =
-      try op catch {
+      try {
+        if (!isInteractive) realStdout.println(s"Testing ${testSource.title}")
+        op
+      } catch {
         case NonFatal(e) => {
           // if an exception is thrown during compilation, the complete test
           // run should fail
@@ -295,8 +316,10 @@ trait ParallelTesting { self =>
         Runtime.getRuntime.exec(fullArgs).waitFor() == 0
       } else true
 
-      val reporter = TestReporter.parallelReporter(this, logLevel =
-        if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR)
+      val reporter =
+        TestReporter.reporter(realStdout, logLevel =
+          if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR)
+
       val driver =
         if (times == 1) new Driver { def newCompiler(implicit ctx: Context) = new Compiler }
         else new Driver {
@@ -339,8 +362,12 @@ trait ParallelTesting { self =>
         }
 
         pool.shutdown()
-        if (!pool.awaitTermination(10, TimeUnit.MINUTES))
+        if (!pool.awaitTermination(20, TimeUnit.MINUTES)) {
+          pool.shutdownNow()
+          System.setOut(realStdout)
+          System.setErr(realStderr)
           throw new TimeoutException("Compiling targets timed out")
+        }
 
         if (didFail) {
           reportFailed()
@@ -403,8 +430,6 @@ trait ParallelTesting { self =>
       import java.net.{ URL, URLClassLoader }
 
       val printStream = new ByteArrayOutputStream
-      val oldOut = System.out
-      val oldErr = System.err
 
       try {
         // Do classloading magic and running here:
@@ -412,7 +437,7 @@ trait ParallelTesting { self =>
         val cls = ucl.loadClass("Test")
         val meth = cls.getMethod("main", classOf[Array[String]])
 
-        self.synchronized {
+        synchronized {
           try {
             val ps = new PrintStream(printStream)
             System.setOut(ps)
@@ -422,9 +447,13 @@ trait ParallelTesting { self =>
                 meth.invoke(null, Array("jvm")) // partest passes at least "jvm" as an arg
               }
             }
-          } finally {
-            System.setOut(oldOut)
-            System.setErr(oldErr)
+            System.setOut(realStdout)
+            System.setErr(realStderr)
+          } catch {
+            case t: Throwable =>
+              System.setOut(realStdout)
+              System.setErr(realStderr)
+              throw t
           }
         }
       }
@@ -447,6 +476,7 @@ trait ParallelTesting { self =>
     private def verifyOutput(checkFile: JFile, dir: JFile, testSource: TestSource, warnings: Int) = {
       val outputLines = runMain(dir, testSource)
       val checkLines = Source.fromFile(checkFile).getLines.toArray
+      val sourceTitle = testSource.title
 
       def linesMatch =
         outputLines
@@ -456,9 +486,13 @@ trait ParallelTesting { self =>
       if (outputLines.length != checkLines.length || !linesMatch) {
         // Print diff to files and summary:
         val diff = outputLines.zip(checkLines).map { case (act, exp) =>
-          DiffUtil.mkColoredCodeDiff(exp, act, true)
+          DiffUtil.mkColoredLineDiff(exp, act)
         }.mkString("\n")
-        val msg = s"\nOutput from run test '$checkFile' did not match expected, output:\n$diff\n"
+
+        val msg =
+          s"""|Output from '$sourceTitle' did not match check file.
+              |Diff ('e' is expected, 'a' is actual):
+              |""".stripMargin + diff + "\n"
         echo(msg)
         addFailureInstruction(msg)
 
@@ -920,9 +954,8 @@ trait ParallelTesting { self =>
   private def compilationTargets(sourceDir: JFile): (List[JFile], List[JFile]) =
     sourceDir.listFiles.foldLeft((List.empty[JFile], List.empty[JFile])) { case ((dirs, files), f) =>
       if (f.isDirectory) (f :: dirs, files)
-      else if (f.getName.endsWith(".check")) (dirs, files)
-      else if (f.getName.endsWith(".flags")) (dirs, files)
-      else (dirs, f :: files)
+      else if (isSourceFile(f)) (dirs, f :: files)
+      else (dirs, files)
     }
 
   /** Gets the name of the calling method via reflection.
diff --git a/compiler/test/dotty/tools/dotc/reporting/TestReporter.scala b/compiler/test/dotty/tools/dotc/reporting/TestReporter.scala
index 521cf9576..5641240a7 100644
--- a/compiler/test/dotty/tools/dotc/reporting/TestReporter.scala
+++ b/compiler/test/dotty/tools/dotc/reporting/TestReporter.scala
@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package reporting
 
-import java.io.{ PrintWriter, File => JFile, FileOutputStream }
+import java.io.{ PrintStream, PrintWriter, File => JFile, FileOutputStream }
 import java.text.SimpleDateFormat
 import java.util.Date
 
@@ -25,10 +25,16 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
   protected final val _messageBuf = mutable.ArrayBuffer.empty[String]
 
   final def flushToFile(): Unit =
-    _messageBuf.iterator.foreach(filePrintln)
+    _messageBuf
+      .iterator
+      .map(_.replaceAll("\u001b\\[.*?m", ""))
+      .foreach(filePrintln)
 
   final def flushToStdErr(): Unit =
-    _messageBuf.iterator.foreach(System.err.println)
+    _messageBuf
+      .iterator
+      .map(_.replaceAll("\u001b\\[.*?m", ""))
+      .foreach(System.err.println)
 
   final def inlineInfo(pos: SourcePosition): String =
     if (pos.exists) {
@@ -75,10 +81,11 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
 }
 
 object TestReporter {
-  private[this] val logWriter = {
+  private[this] lazy val logWriter = {
     val df = new SimpleDateFormat("yyyy-MM-dd-HH:mm")
     val timestamp = df.format(new Date)
-    new PrintWriter(new FileOutputStream(new JFile(s"../tests-$timestamp.log"), true))
+    new JFile("../testlogs").mkdirs()
+    new PrintWriter(new FileOutputStream(new JFile(s"../testlogs/tests-$timestamp.log"), true))
   }
 
   def writeToLog(str: String) = {
@@ -86,38 +93,25 @@ object TestReporter {
     logWriter.flush()
   }
 
-  def parallelReporter(lock: AnyRef, logLevel: Int): TestReporter = new TestReporter(
-    new PrintWriter(Console.err, true),
-    str => lock.synchronized {
-      logWriter.println(str)
-      logWriter.flush()
-    },
-    logLevel
-  )
-
-  def reporter(logLevel: Int): TestReporter = new TestReporter(
-    new PrintWriter(Console.err, true),
-    writeToLog,
-    logLevel
-  )
-
-  def simplifiedReporter(writer: PrintWriter): TestReporter = new TestReporter(
-    writer,
-    writeToLog,
-    WARNING
-  ) {
-    /** Prints the message with the given position indication in a simplified manner */
-    override def printMessageAndPos(m: MessageContainer, extra: String)(implicit ctx: Context): Unit = {
-      val msg = s"${m.pos.line + 1}: " + m.contained.kind + extra
-      val extraInfo = inlineInfo(m.pos)
-
-      writer.println(msg)
-      _messageBuf.append(msg)
-
-      if (extraInfo.nonEmpty) {
-        writer.println(extraInfo)
-        _messageBuf.append(extraInfo)
+  def reporter(ps: PrintStream, logLevel: Int): TestReporter =
+    new TestReporter(new PrintWriter(ps, true), writeToLog, logLevel)
+
+  def simplifiedReporter(writer: PrintWriter): TestReporter = {
+    val rep = new TestReporter(writer, writeToLog, WARNING) {
+      /** Prints the message with the given position indication in a simplified manner */
+      override def printMessageAndPos(m: MessageContainer, extra: String)(implicit ctx: Context): Unit = {
+        val msg = s"${m.pos.line + 1}: " + m.contained.kind + extra
+        val extraInfo = inlineInfo(m.pos)
+
+        writer.println(msg)
+        _messageBuf.append(msg)
+
+        if (extraInfo.nonEmpty) {
+          writer.println(extraInfo)
+          _messageBuf.append(extraInfo)
+        }
       }
     }
+    rep
   }
 }
diff --git a/doc-tool/resources/css/dottydoc.css b/doc-tool/resources/css/dottydoc.css
index 0b833830c..a89e23375 100644
--- a/doc-tool/resources/css/dottydoc.css
+++ b/doc-tool/resources/css/dottydoc.css
@@ -334,3 +334,23 @@ blockquote {
     color: #777;
     border-left: 0.25em solid #ddd;
 }
+
+aside {
+    padding: 15px;
+    margin: 10px 0;
+}
+
+aside.warning {
+    border-left: 3px solid #d62c2c;
+    background-color: #ffe4e4;
+}
+
+aside.notice {
+    border-left: 3px solid #4c97e4;
+    background-color: #e4ebff;
+}
+
+aside.success {
+    border-left: 3px solid #36bf1d;
+    background-color: #ebfddd;
+}
diff --git a/docs/docs/contributing/testing.md b/docs/docs/contributing/testing.md
new file mode 100644
index 000000000..07aab1918
--- /dev/null
+++ b/docs/docs/contributing/testing.md
@@ -0,0 +1,89 @@
+---
+layout: doc-page
+title: Testing in Dotty
+---
+
+<aside class="warning">
+This page should be updated as soon as scala-partest is removed
+</aside>
+
+Running all tests in Dotty is as simple as:
+
+```bash
+$ sbt test
+```
+
+There are currently several forms of tests in Dotty. These can be split into
+two categories:
+
+## Unit tests
+These tests can be found in `<sub-project>/test` and are used to check
+functionality of specific parts of the codebase in isolation e.g: parsing,
+scanning and message errors.
+
+Running a single unit test class from sbt is as simple as:
+
+```bash
+> testOnly absolute.path.to.TestClass
+```
+
+You can further restrict the executed tests to a subset of `TestClass` methods
+as follows:
+
+```bash
+> testOnly absolute.path.to.TestClass -- *methodName
+```
+
+## Integration tests
+These tests are Scala source files expected to compile with Dotty (pos tests),
+along with their expected output (run tests) or errors (neg tests).
+
+All of these tests are contained in the `./tests/*` directories.
+
+## scala-partest
+Historically these tests needed a structure which was generated by running the
+unit tests, and then that structure was in turn used by
+[scala-partest](http://github.com/scala/scala-partest) to run compilation tests
+in parallel.
+
+This test suite can still be used (and is currently a part of the CI to check
+that it has the same outcome as the new test suite). It is invoked from sbt by
+running one of the following commands:
+
+```bash
+> partest-only-no-bootstrap
+> partest-only
+> partest
+```
+
+- `partest-only-no-bootstrap` will only run the integration tests
+- `partest-only` will bootstrap the compiler and run the integration tests
+- `partest` will bootstrap the compiler, run the unit tests and then the
+  integration tests
+
+## dotty parallel test suite
+The new test suite will soon become the standard integration test runner. It
+has several advantages over the old implementation:
+
+- integrates with JUnit, without the need for setup
+- reuses the same VM for compilation
+- allows filtering of tests
+- runs much faster (almost 2x)
+
+Currently to run these tests you need to invoke from sbt:
+
+```bash
+> testOnly dotty.tools.dotc.CompilationTests
+```
+
+This might be aliased in the future. It is also possible to run tests filtered
+by using:
+
+```bash
+> filterTest .*i2147.scala
+```
+
+This will run both the test `./tests/pos/i2147.scala` and
+`./tests/partest-test/i2147.scala` since both of these match the given regular
+expression. This also means that you could run `filterTest .*` to run all
+integration tests.
diff --git a/docs/docs/contributing/workflow.md b/docs/docs/contributing/workflow.md
index 6e7f5b9a0..3c654e8f6 100644
--- a/docs/docs/contributing/workflow.md
+++ b/docs/docs/contributing/workflow.md
@@ -57,11 +57,21 @@ $ sbt
 To test a specific test tests/x/y.scala (for example tests/pos/t210.scala):
 
 ```bash
-> partest-only-no-bootstrap --show-diff --verbose tests/partest-generated/x/y.scala
+> filterTest .*pos/t210.scala
 ```
 
-Currently this will re-run some unit tests and do some preprocessing because of
-the way partest has been set up.
+The filterTest task takes a regular expression as its argument. For example,
+you could run a negative and a positive test with:
+
+```bash
+> filterTest (.*pos/t697.scala)|(.*neg/i2101.scala)
+```
+
+or if they have the same name, the equivalent can be achieved with:
+
+```bash
+> filterTest .*/i2101.scala
+```
 
 ## Inspecting Trees with Type Stealer ##
 
diff --git a/docs/docs/internals/higher-kinded-v2.md b/docs/docs/internals/higher-kinded-v2.md
index 4676d3ebd..3c857d4d5 100644
--- a/docs/docs/internals/higher-kinded-v2.md
+++ b/docs/docs/internals/higher-kinded-v2.md
@@ -3,10 +3,11 @@ layout: doc-page
 title: "Higher-Kinded Types in Dotty"
 ---
 
-**This page is out of date and preserved for posterity. Please see [Implementing
-Higher-Kinded Types in
-Dotty](http://guillaume.martres.me/publications/dotty-hk.pdf) for a more up to
-date version**
+<aside class="warning">
+    This page is out of date and preserved for posterity. Please see
+    <a href="http://guillaume.martres.me/publications/dotty-hk.pdf">
+    Implementing Higher-Kinded Types in Dotty</a> for a more up to date version
+</aside>
 
 Higher-Kinded Types in Dotty V2
 ===============================
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
index 7ffa1f5b7..4065cff20 100644
--- a/docs/sidebar.yml
+++ b/docs/sidebar.yml
@@ -23,6 +23,8 @@ sidebar:
           url: docs/contributing/intellij-idea.html
         - title: Workflow
           url: docs/contributing/workflow.html
+        - title: Testing
+          url: docs/contributing/testing.html
     - title: Internals
       subsection:
         - title: Backend
diff --git a/tests/neg/i2151.scala b/tests/neg/i2151.scala
new file mode 100644
index 000000000..1ae034c02
--- /dev/null
+++ b/tests/neg/i2151.scala
@@ -0,0 +1,6 @@
+trait Test {
+  type Nil = [K] => K
+  type StrangeCons[H, Tail <: [H, A] => H] = Tail[H, H]
+
+  def list: StrangeCons[Int, Nil] // error
+}
diff --git a/tests/run/i2156.scala b/tests/run/i2156.scala
new file mode 100644
index 000000000..12ce8fa88
--- /dev/null
+++ b/tests/run/i2156.scala
@@ -0,0 +1,37 @@
+class Outer {
+
+  case class Inner()
+
+  val inner: Inner = new Inner
+
+  def checkInstance(o: Outer) =
+    o.inner.isInstanceOf[this.Inner]
+
+  def checkPattern1(i: Any) =
+    i match {
+      case _: Inner => true
+      case _ => false
+    }
+
+  def checkPattern2(i: Any) =
+    i match {
+      case Inner() => true
+      case _ => false
+    }
+
+  def checkEquals(o: Outer) =
+    o.inner == inner
+}
+
+object Test {
+
+  def main(args: Array[String]) = {
+    val o1 = new Outer
+    val o2 = new Outer
+    assert(o1.checkInstance(o2)) // ok
+    assert(!o1.checkPattern1(o2.inner)) // ok under scalac, fails for dotc-compiled code
+    assert(!o1.checkPattern2(o2.inner))  // ok under scalac, fails for dotc-compiled code
+    assert(!o1.checkEquals(o2))  // ok under scalac, fails for dotc-compiled code
+  }
+}
+