Revert "Add clear separation between flags and classpath in tests"

This reverts commit 1ce86d4.

Author: nicolasstucki

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

@@ -102,6 +102,7 @@ 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, TestFlags}
+import dotty.tools.vulpix.ParallelTesting
 
 import scala.concurrent.duration._
 
@@ -26,6 +26,9 @@ object comptest extends ParallelTesting {
         dotcDir + "tools/dotc/core/Types.scala",
         dotcDir + "tools/dotc/ast/Trees.scala"
       ),
-      TestFlags("", Array("-Ylog:frontend", "-Xprompt"))
+      Array(
+        "-Ylog:frontend",
+        "-Xprompt"
+      )
   )
 }

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

@@ -10,7 +10,8 @@ import java.util.stream.{ Stream => JStream }
 import scala.collection.JavaConverters._
 import scala.util.matching.Regex
 import scala.concurrent.duration._
-import vulpix._
+
+import vulpix.{ ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration }
 import dotty.tools.io.JFile
 
 
@@ -40,7 +41,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", TestFlags(classPath, noCheckOptions)) +
+    compileDir("../compiler/src/dotty/tools/dotc/core", noCheckOptions ++ classPath) +
     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) +
@@ -222,13 +223,14 @@ class CompilationTests extends ParallelTesting {
    *  version of Dotty
    */
   @Test def tastyBootstrap: Unit = {
-    val opt = TestFlags(
+    val opt = Array(
+      "-classpath",
       // compile with bootstrapped library on cp:
       defaultOutputDir + "lib/src/:" +
       // as well as bootstrapped compiler:
       defaultOutputDir + "dotty1/dotty/:" +
       Jars.dottyInterfaces,
-      Array("-Ycheck-reentrant")
+      "-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._
+import vulpix.{ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration}
 
 import scala.concurrent.duration._
 import scala.collection.JavaConverters._
@@ -38,17 +38,17 @@ class LinkOptimiseTests extends ParallelTesting {
     }.keepOutput.checkCompile()
 
     // Setup class paths
-    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")
+    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")
 
     // Link tests
     val linkDir = "../tests/link"
     val linkStramanDir = linkDir + "/strawman"
     val linkCustomLibDir = linkDir + "/on-custom-lib"
-    def linkStrawmanTest = compileFilesInDir(linkStramanDir, strawmanClassPath)
-    def linkCustomLibTest = compileFilesInDir(linkCustomLibDir, customLibClassFlags)
+    def linkStrawmanTest = compileFilesInDir(linkStramanDir, basicLinkOptimise ++ strawmanClassPath)
+    def linkCustomLibTest = compileFilesInDir(linkCustomLibDir, basicLinkOptimise ++ customLibClassPath)
 
     def classFileChecks(sourceDir: String, testName: String) = {
       val checkExt = ".classcheck"

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", "-classpath", TestConfiguration.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

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

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

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