Add clear separation between flags and classpath in tests

Author: nicolasstucki

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -102,7 +102,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val YcheckAllPatmat = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
   val YretainTrees = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
   val YshowTreeIds = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")
-  val YRunClasspath = PathSetting("-YRunClasspath", "Specify where to find user class files while executing run tests.", defaultClasspath)
 
   /** Area-specific debug output */
   val Yexplainlowlevel = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

compiler/test/dotc/comptest.scala

@@ -1,6 +1,6 @@
 package dotc
 
-import dotty.tools.vulpix.ParallelTesting
+import dotty.tools.vulpix.{ParallelTesting, TestFlags}
 
 import scala.concurrent.duration._
 
@@ -26,9 +26,6 @@ object comptest extends ParallelTesting {
         dotcDir + "tools/dotc/core/Types.scala",
         dotcDir + "tools/dotc/ast/Trees.scala"
       ),
-      Array(
-        "-Ylog:frontend",
-        "-Xprompt"
-      )
+      TestFlags("", Array("-Ylog:frontend", "-Xprompt"))
   )
 }

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

@@ -10,8 +10,7 @@ import java.util.stream.{ Stream => JStream }
 import scala.collection.JavaConverters._
 import scala.util.matching.Regex
 import scala.concurrent.duration._
-
-import vulpix.{ ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration }
+import vulpix._
 import dotty.tools.io.JFile
 
 
@@ -41,7 +40,7 @@ class CompilationTests extends ParallelTesting {
     compileDir("../compiler/src/dotty/tools/dotc/typer", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/util", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/io", defaultOptions) +
-    compileDir("../compiler/src/dotty/tools/dotc/core", noCheckOptions ++ classPath) +
+    compileDir("../compiler/src/dotty/tools/dotc/core", TestFlags(classPath, noCheckOptions)) +
     compileFile("../tests/pos/nullarify.scala", defaultOptions.and("-Ycheck:nullarify")) +
     compileFile("../tests/pos-scala2/rewrites.scala", scala2Mode.and("-rewrite")).copyToTarget() +
     compileFile("../tests/pos-special/t8146a.scala", allowDeepSubtypes) +
@@ -223,14 +222,13 @@ class CompilationTests extends ParallelTesting {
    *  version of Dotty
    */
   @Test def tastyBootstrap: Unit = {
-    val opt = Array(
-      "-classpath",
+    val opt = TestFlags(
       // compile with bootstrapped library on cp:
       defaultOutputDir + "lib/src/:" +
       // as well as bootstrapped compiler:
       defaultOutputDir + "dotty1/dotty/:" +
       Jars.dottyInterfaces,
-      "-Ycheck-reentrant"
+      Array("-Ycheck-reentrant")
     )
 
     def lib =

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

@@ -7,7 +7,7 @@ import java.nio.file.{Files, Path, Paths}
 
 import org.junit.{AfterClass, Test}
 import org.junit.Assert._
-import vulpix.{ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration}
+import vulpix._
 
 import scala.concurrent.duration._
 import scala.collection.JavaConverters._
@@ -38,17 +38,17 @@ class LinkOptimiseTests extends ParallelTesting {
     }.keepOutput.checkCompile()
 
     // Setup class paths
-    def mkLinkClassPath(libPath: String) =
-      mkClassPath(libPath :: Jars.dottyTestDeps) ++ mkClassPath(Jars.dottyTestDeps, "-YRunClasspath")
-    val strawmanClassPath = mkLinkClassPath(defaultOutputDir + "strawmanLibrary/main/")
-    val customLibClassPath = mkLinkClassPath(defaultOutputDir + "linkCustomLib/custom-lib")
+    def mkLinkClassFlags(libPath: String) =
+      TestFlags(mkClassPath(libPath :: Jars.dottyTestDeps), mkClassPath(Jars.dottyTestDeps), basicDefaultOptions :+ "-Xlink-optimise")
+    val strawmanClassPath = mkLinkClassFlags(defaultOutputDir + "strawmanLibrary/main/")
+    val customLibClassFlags = mkLinkClassFlags(defaultOutputDir + "linkCustomLib/custom-lib")
 
     // Link tests
     val linkDir = "../tests/link"
     val linkStramanDir = linkDir + "/strawman"
     val linkCustomLibDir = linkDir + "/on-custom-lib"
-    def linkStrawmanTest = compileFilesInDir(linkStramanDir, basicLinkOptimise ++ strawmanClassPath)
-    def linkCustomLibTest = compileFilesInDir(linkCustomLibDir, basicLinkOptimise ++ customLibClassPath)
+    def linkStrawmanTest = compileFilesInDir(linkStramanDir, strawmanClassPath)
+    def linkCustomLibTest = compileFilesInDir(linkCustomLibDir, customLibClassFlags)
 
     def classFileChecks(sourceDir: String, testName: String) = {
       val checkExt = ".classcheck"

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

@@ -2,9 +2,8 @@ package dotty
 package tools
 package dotc
 
-import org.junit.{ Test, AfterClass }
-
-import vulpix.{ ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration }
+import org.junit.{AfterClass, Test}
+import vulpix._
 
 import scala.concurrent.duration._
 
@@ -22,8 +21,8 @@ class MissingCoreLibTests extends ParallelTesting {
 
   @Test def missingDottyLib: Unit = {
     val classPath = mkClassPath(Jars.dottyCompiler :: Jars.dottyInterfaces :: Jars.dottyExtras) // missing Jars.dottyLib
-    val options = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath
-    compileFile("../tests/neg/nolib/Foo.scala", options).checkExpectedErrors()
+    val options = noCheckOptions ++ checkOptions ++ yCheckOptions
+    compileFile("../tests/neg/nolib/Foo.scala", TestFlags(classPath, options)).checkExpectedErrors()
   }
 
 }

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

@@ -14,7 +14,7 @@ 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") ++ TestConfiguration.classPath
+  val options = List("-color:never", "-Ystop-after:splitter", "-Ycheck-all-patmat", "-classpath", TestConfiguration.classPath)
 
   private def compileFile(file: File) = {
     val stringBuffer = new StringWriter()

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

@@ -50,25 +50,9 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   private sealed trait TestSource { self =>
     def name: String
     def outDir: JFile
-    def flags: Array[String]
-
-    def classPath: String =
-      outDir.getAbsolutePath +
-      flags
-        .dropWhile(_ != "-classpath")
-        .drop(1)
-        .headOption
-        .map(":" + _)
-        .getOrElse("")
+    def flags: TestFlags
 
-    def runClassPath = {
-      flags
-        .dropWhile(_ != "-YRunClasspath")
-        .drop(1)
-        .headOption
-        .map(outDir.getAbsolutePath + ":" + _)
-        .getOrElse(classPath)
-    }
+    def runClassPath: String = outDir.getAbsolutePath + ":" + flags.runClassPath
 
     def title: String = self match {
       case self: JointCompilationSource =>
@@ -82,11 +66,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     /** Adds the flags specified in `newFlags0` if they do not already exist */
     def withFlags(newFlags0: String*) = {
       val newFlags = newFlags0.toArray
-      if (!flags.containsSlice(newFlags)) self match {
+      if (!flags.options.containsSlice(newFlags)) self match {
         case self: JointCompilationSource =>
-          self.copy(flags = flags ++ newFlags)
+          self.copy(flags = flags.and(newFlags:_*))
         case self: SeparateCompilationSource =>
-          self.copy(flags = flags ++ newFlags)
+          self.copy(flags = flags.and(newFlags:_*))
       }
       else self
     }
@@ -103,7 +87,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             |the test can be reproduced by running:""".stripMargin
       )
       sb.append("\n\n./bin/dotc ")
-      flags.foreach { arg =>
+      flags.all.foreach { arg =>
         if (lineLen > maxLen) {
           sb.append(" \\\n        ")
           lineLen = 4
@@ -147,7 +131,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   private final case class JointCompilationSource(
     name: String,
     files: Array[JFile],
-    flags: Array[String],
+    flags: TestFlags,
     outDir: JFile
   ) extends TestSource {
     def sourceFiles: Array[JFile] = files.filter(isSourceFile)
@@ -161,7 +145,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   private final case class SeparateCompilationSource(
     name: String,
     dir: JFile,
-    flags: Array[String],
+    flags: TestFlags,
     outDir: JFile
   ) extends TestSource {
 
@@ -342,9 +326,9 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         }
       }
 
-    protected def compile(files0: Array[JFile], flags0: Array[String], suppressErrors: Boolean, targetDir: JFile): TestReporter = {
+    protected def compile(files0: Array[JFile], flags0: TestFlags, suppressErrors: Boolean, targetDir: JFile): TestReporter = {
 
-      val flags = flags0 ++ Array("-d", targetDir.getAbsolutePath)
+      val flags = flags0 and ("-d", targetDir.getAbsolutePath)
 
       def flattenFiles(f: JFile): Array[JFile] =
         if (f.isDirectory) f.listFiles.flatMap(flattenFiles)
@@ -367,7 +351,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
           "-encoding", "UTF-8",
           "-classpath",
           s".:${Jars.scalaLibrary}:${targetDir.getAbsolutePath}"
-        ) ++ flags.takeRight(2) ++ fs
+        ) ++ flags.all.takeRight(2) ++ fs
 
         val process = Runtime.getRuntime.exec(fullArgs)
         val output = Source.fromInputStream(process.getErrorStream).mkString
@@ -395,7 +379,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             }
         }
 
-      val allArgs = addOutDir(flags)
+      val allArgs = addOutDir(flags.all)
 
       // Compile with a try to catch any StackTrace generated by the compiler:
       try {
@@ -1073,7 +1057,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   }
 
   /** Compiles a single file from the string path `f` using the supplied flags */
-  def compileFile(f: String, flags: Array[String])(implicit outDirectory: String): CompilationTest = {
+  def compileFile(f: String, flags: TestFlags)(implicit outDirectory: String): CompilationTest = {
     val callingMethod = getCallingMethod()
     val sourceFile = new JFile(f)
     val parent = sourceFile.getParentFile
@@ -1103,7 +1087,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
    *  By default, files are compiled in alphabetical order. An optional seed
    *  can be used for randomization.
    */
-  def compileDir(f: String, flags: Array[String], randomOrder: Option[Int] = None)(implicit outDirectory: String): CompilationTest = {
+  def compileDir(f: String, flags: TestFlags, randomOrder: Option[Int] = None)(implicit outDirectory: String): CompilationTest = {
     val callingMethod = getCallingMethod()
     val outDir = outDirectory + callingMethod + "/"
     val sourceDir = new JFile(f)
@@ -1132,7 +1116,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
    *  `testName` since files can be in separate directories and or be otherwise
    *  dissociated
    */
-  def compileList(testName: String, files: List[String], flags: Array[String], callingMethod: String = getCallingMethod())(implicit outDirectory: String): CompilationTest = {
+  def compileList(testName: String, files: List[String], flags: TestFlags, callingMethod: String = getCallingMethod())(implicit outDirectory: String): CompilationTest = {
     val outDir = outDirectory + callingMethod + "/" + testName + "/"
 
     // Directories in which to compile all containing files with `flags`:
@@ -1163,7 +1147,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
    *  - Directories can have an associated check-file, where the check file has
    *    the same name as the directory (with the file extension `.check`)
    */
-  def compileFilesInDir(f: String, flags: Array[String])(implicit outDirectory: String): CompilationTest = {
+  def compileFilesInDir(f: String, flags: TestFlags)(implicit outDirectory: String): CompilationTest = {
     val callingMethod = getCallingMethod()
     val outDir = outDirectory + callingMethod + "/"
     val sourceDir = new JFile(f)
@@ -1183,7 +1167,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
    *  sub-directories and as such, does **not** perform separate compilation
    *  tests.
    */
-  def compileShallowFilesInDir(f: String, flags: Array[String])(implicit outDirectory: String): CompilationTest = {
+  def compileShallowFilesInDir(f: String, flags: TestFlags)(implicit outDirectory: String): CompilationTest = {
     val callingMethod = getCallingMethod()
     val outDir = outDirectory + callingMethod + "/"
     val sourceDir = new JFile(f)

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

@@ -5,13 +5,6 @@ package vulpix
 object TestConfiguration {
   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"
@@ -25,8 +18,8 @@ object TestConfiguration {
 
   val classPath = mkClassPath(Jars.dottyTestDeps)
 
-  def mkClassPath(classPaths: List[String], classPathFlag: String = "-classpath"): Array[String] = {
-    val paths = classPaths map { p =>
+  def mkClassPath(classPaths: List[String]): String = {
+    classPaths map { p =>
       val file = new java.io.File(p)
       assert(
         file.exists,
@@ -47,26 +40,23 @@ object TestConfiguration {
             |it in extras."""
       )
       file.getAbsolutePath
-    } mkString (":")
-
-    Array(classPathFlag, paths)
+    } mkString(":")
   }
 
   val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,erasure,mixin,getClass,restoreScopes,labelDef")
 
-  val basicDefaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions
-  val defaultUnoptimised = basicDefaultOptions ++ classPath
-  val defaultOptimised = defaultUnoptimised :+ "-optimise"
+  val basicDefaultOptions = checkOptions ++ noCheckOptions ++ yCheckOptions
+  val defaultUnoptimised = TestFlags(classPath, basicDefaultOptions)
+  val defaultOptimised = defaultUnoptimised and "-optimise"
   val defaultOptions = defaultUnoptimised
-  val allowDeepSubtypes = defaultOptions diff Array("-Yno-deep-subtypes")
-  val allowDoubleBindings = defaultOptions diff Array("-Yno-double-bindings")
-  val picklingOptions = defaultUnoptimised ++ Array(
+  val allowDeepSubtypes = defaultOptions without "-Yno-deep-subtypes"
+  val allowDoubleBindings = defaultOptions without "-Yno-double-bindings"
+  val picklingOptions = defaultUnoptimised and (
     "-Xprint-types",
     "-Ytest-pickler",
     "-Yprintpos"
   )
-  val scala2Mode = defaultOptions ++ Array("-language:Scala2")
-  val explicitUTF8 = defaultOptions ++ Array("-encoding", "UTF8")
-  val explicitUTF16 = defaultOptions ++ Array("-encoding", "UTF16")
-  val basicLinkOptimise = basicDefaultOptions ++ Array("-Xlink-optimise")
+  val scala2Mode = defaultOptions and "-language:Scala2"
+  val explicitUTF8 = defaultOptions and ("-encoding", "UTF8")
+  val explicitUTF16 = defaultOptions and ("-encoding", "UTF16")
 }

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

@@ -0,0 +1,19 @@
+package dotty.tools.vulpix
+
+final case class TestFlags(
+  defaultClassPath: String,
+  runClassPath: String, // class path that is used when running `run` tests (not compiling)
+  options: Array[String]) {
+
+  def and(flags: String*): TestFlags =
+    TestFlags(defaultClassPath, runClassPath, options ++ flags)
+
+  def without(flags: String*): TestFlags =
+    TestFlags(defaultClassPath, runClassPath, options diff flags)
+
+  def all: Array[String] = Array("-classpath", defaultClassPath) ++ options
+}
+
+object TestFlags {
+  def apply(classPath: String, flags: Array[String]): TestFlags = TestFlags(classPath, classPath, flags)
+}