Remove need for java written summary reporter

Author: felixmulder

compiler/test/dotc/tests.scala

@@ -210,8 +210,8 @@ class tests extends CompilerTest {
   private val stdlibFiles: List[String] = StdLibSources.whitelisted
 
   @Test def compileStdLib =
-    if (!generatePartestFiles)
-      compileList("compileStdLib", stdlibFiles, "-migration" :: "-Yno-inline" :: scala2mode)
+    compileList("compileStdLib", stdlibFiles, "-migration" :: "-Yno-inline" :: scala2mode)
+
   @Test def compileMixed = compileLine(
       """../tests/pos/B.scala
         |../scala-scala/src/library/scala/collection/immutable/Seq.scala

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -2,14 +2,15 @@ package dotty
 package tools
 package dotc
 
-import org.junit.Test
+import org.junit.{ Test, BeforeClass, AfterClass }
 
 import scala.util.matching.Regex
 import scala.concurrent.duration._
 
-import vulpix.{ ParallelTesting, SummaryReport }
+import vulpix.{ ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration }
 
-class CompilationTests extends SummaryReport with ParallelTesting {
+class CompilationTests extends ParallelTesting {
+  import TestConfiguration._
   import CompilationTests._
 
   // Test suite configuration --------------------------------------------------
@@ -252,65 +253,6 @@ class CompilationTests extends SummaryReport with ParallelTesting {
 }
 
 object CompilationTests {
-  implicit val defaultOutputDir: String = "../out/"
-
-  implicit class RichStringArray(val xs: Array[String]) extends AnyVal {
-    def and(args: String*): Array[String] = {
-      val argsArr: Array[String] = args.toArray
-      xs ++ argsArr
-    }
-  }
-
-  val noCheckOptions = Array(
-    "-pagewidth", "120",
-    "-color:never"
-  )
-
-  val checkOptions = Array(
-    "-Yno-deep-subtypes",
-    "-Yno-double-bindings",
-    "-Yforce-sbt-phases"
-  )
-
-  val classPath = {
-    val paths = Jars.dottyTestDeps map { p =>
-      val file = new java.io.File(p)
-      assert(
-        file.exists,
-        s"""|File "$p" couldn't be found. Run `packageAll` from build tool before
-            |testing.
-            |
-            |If running without sbt, test paths need to be setup environment variables:
-            |
-            | - DOTTY_LIBRARY
-            | - DOTTY_COMPILER
-            | - DOTTY_INTERFACES
-            | - DOTTY_EXTRAS
-            |
-            |Where these all contain locations, except extras which is a colon
-            |separated list of jars.
-            |
-            |When compiling with eclipse, you need the sbt-interfaces jar, put
-            |it in extras."""
-      )
-      file.getAbsolutePath
-    } mkString (":")
-
-    Array("-classpath", paths)
-  }
-
-  private val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef")
-
-  val defaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath
-  val allowDeepSubtypes = defaultOptions diff Array("-Yno-deep-subtypes")
-  val allowDoubleBindings = defaultOptions diff Array("-Yno-double-bindings")
-  val picklingOptions = defaultOptions ++ Array(
-    "-Xprint-types",
-    "-Ytest-pickler",
-    "-Ystop-after:pickler",
-    "-Yprintpos"
-  )
-  val scala2Mode = defaultOptions ++ Array("-language:Scala2")
-  val explicitUTF8 = defaultOptions ++ Array("-encoding", "UTF8")
-  val explicitUTF16 = defaultOptions ++ Array("-encoding", "UTF16")
+  implicit val summaryReport: SummaryReporting = new SummaryReport
+  @AfterClass def cleanup(): Unit = summaryReport.echoSummary()
 }

compiler/test/dotty/tools/dotc/reporting/TestReporter.scala

@@ -110,15 +110,22 @@ object 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)
+        def report() = {
+          val msg = s"${m.pos.line + 1}: " + m.contained.kind + extra
+          val extraInfo = inlineInfo(m.pos)
 
-        writer.println(msg)
-        _messageBuf.append(msg)
+          writer.println(msg)
+          _messageBuf.append(msg)
 
-        if (extraInfo.nonEmpty) {
-          writer.println(extraInfo)
-          _messageBuf.append(extraInfo)
+          if (extraInfo.nonEmpty) {
+            writer.println(extraInfo)
+            _messageBuf.append(extraInfo)
+          }
+        }
+        m match {
+          case m: Error => report()
+          case m: Warning => report()
+          case _ => ()
         }
       }
     }

compiler/test/dotty/tools/dotc/transform/PatmatExhaustivityTest.scala

@@ -9,11 +9,12 @@ import scala.io.Source._
 import scala.reflect.io.Directory
 import org.junit.Test
 import reporting.TestReporter
+import vulpix.TestConfiguration
 
 class PatmatExhaustivityTest {
   val testsDir = "../tests/patmat"
   // stop-after: patmatexhaust-huge.scala crash compiler
-  val options = List("-color:never", "-Ystop-after:splitter", "-Ycheck-all-patmat") ++ CompilationTests.classPath
+  val options = List("-color:never", "-Ystop-after:splitter", "-Ycheck-all-patmat") ++ TestConfiguration.classPath
 
   private def compileFile(file: File) = {
     val stringBuffer = new StringWriter()

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -32,7 +32,6 @@ import dotc.{ Driver, Compiler }
 trait ParallelTesting extends RunnerOrchestration { self =>
 
   import ParallelTesting._
-  import SummaryReport._
 
   /** If the running environment supports an interactive terminal, each `Test`
    *  will be run with a progress bar and real time feedback
@@ -183,7 +182,10 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** Each `Test` takes the `testSources` and performs the compilation and assertions
    *  according to the implementing class "neg", "run" or "pos".
    */
-  private abstract class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean) { test =>
+  private abstract class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit val summaryReport: SummaryReporting) { test =>
+
+    import summaryReport._
+
     protected final val realStdout = System.out
     protected final val realStderr = System.err
 
@@ -426,7 +428,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     }
   }
 
-  private final class PosTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)
+  private final class PosTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
   extends Test(testSources, times, threadLimit, suppressAllOutput) {
     protected def encapsulatedCompilation(testSource: TestSource) = new LoggedRunnable {
       def checkTestSource(): Unit = tryCompile(testSource) {
@@ -465,12 +467,12 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     }
   }
 
-  private final class RunTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)
+  private final class RunTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
   extends Test(testSources, times, threadLimit, suppressAllOutput) {
     private[this] var didAddNoRunWarning = false
     private[this] def addNoRunWarning() = if (!didAddNoRunWarning) {
       didAddNoRunWarning = true
-      SummaryReport.addStartingMessage {
+      summaryReport.addStartingMessage {
         """|WARNING
            |-------
            |Run tests were only compiled, not run - this is due to `dotty.tests.norun`
@@ -593,7 +595,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     }
   }
 
-  private final class NegTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)
+  private final class NegTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
   extends Test(testSources, times, threadLimit, suppressAllOutput) {
     protected def encapsulatedCompilation(testSource: TestSource) = new LoggedRunnable {
       def checkTestSource(): Unit = tryCompile(testSource) {
@@ -849,7 +851,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
      *  compilation without generating errors and that they do not crash the
      *  compiler
      */
-    def checkCompile(): this.type = {
+    def checkCompile()(implicit summaryReport: SummaryReporting): this.type = {
       val test = new PosTest(targets, times, threadLimit, shouldFail).executeTestSuite()
 
       if (!shouldFail && test.didFail) {
@@ -866,7 +868,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
      *  correct amount of errors at the correct positions. It also makes sure
      *  that none of these tests crash the compiler
      */
-    def checkExpectedErrors(): this.type = {
+    def checkExpectedErrors()(implicit summaryReport: SummaryReporting): this.type = {
       val test = new NegTest(targets, times, threadLimit, shouldFail).executeTestSuite()
 
       if (!shouldFail && test.didFail) {
@@ -884,7 +886,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
      *  the compiler; it also makes sure that all tests can run with the
      *  expected output
      */
-    def checkRuns(): this.type = {
+    def checkRuns()(implicit summaryReport: SummaryReporting): this.type = {
       val test = new RunTest(targets, times, threadLimit, shouldFail).executeTestSuite()
 
       if (!shouldFail && test.didFail) {

compiler/test/dotty/tools/vulpix/RunnerOrchestration.scala

@@ -43,7 +43,8 @@ trait RunnerOrchestration {
   def safeMode: Boolean
 
   /** Running a `Test` class's main method from the specified `dir` */
-  def runMain(classPath: String): Status = monitor.runMain(classPath)
+  def runMain(classPath: String)(implicit summaryReport: SummaryReporting): Status =
+    monitor.runMain(classPath)
 
   private[this] val monitor = new RunnerMonitor
 
@@ -57,7 +58,8 @@ trait RunnerOrchestration {
    */
   private class RunnerMonitor {
 
-    def runMain(classPath: String): Status = withRunner(_.runMain(classPath))
+    def runMain(classPath: String)(implicit summaryReport: SummaryReporting): Status =
+      withRunner(_.runMain(classPath))
 
     private class Runner(private var process: Process) {
       private[this] var childStdout: BufferedReader = _
@@ -81,8 +83,16 @@ trait RunnerOrchestration {
         childStdin = null
       }
 
+      /** Did add hook to kill the child VMs? */
+      private[this] var didAddCleanupCallback = false
+
       /** Blocks less than `maxDuration` while running `Test.main` from `dir` */
-      def runMain(classPath: String): Status = {
+      def runMain(classPath: String)(implicit summaryReport: SummaryReporting): Status = {
+        if (!didAddCleanupCallback) {
+          // If for some reason the test runner (i.e. sbt) doesn't kill the VM, we
+          // need to clean up ourselves.
+          summaryReport.addCleanup(killAll)
+        }
         assert(process ne null,
           "Runner was killed and then reused without setting a new process")
 
@@ -127,9 +137,9 @@ trait RunnerOrchestration {
         // Handle failure of the VM:
         status match {
           case _: Success if safeMode => respawn()
+          case _: Success => // no need to respawn sub process
           case _: Failure => respawn()
           case Timeout => respawn()
-          case _ => ()
         }
         status
       }
@@ -182,8 +192,5 @@ trait RunnerOrchestration {
 
     // On shutdown, we need to kill all runners:
     sys.addShutdownHook(killAll())
-    // If for some reason the test runner (i.e. sbt) doesn't kill the VM, we
-    // need to clean up ourselves.
-    SummaryReport.addCleanup(killAll)
   }
 }