Adapt tests for Java 9

- scala-library and scala-xml used to be on the bootclasspath and need
  to be on the regular classpath now.

- Jars.findJarFromRuntime relied on ClassLoader.getSystemClassLoader
  being an URLClassLoader, this isn't true anymore in Java 9. This is
  replaced by passing properties from the sbt build instead, like we were
  already doing for the dotty jars. While I was at it I completely killed
  dotty.Jars and cleaned things a bit.

Author: smarter

compiler/test/dotty/Jars.scala

@@ -32,18 +32,30 @@ object Properties {
    */
   val testsSafeMode: Boolean = sys.props.isDefinedAt("dotty.tests.safemode")
 
-  /** Dotty compiler path provided through define */
-  def dottyCompiler: String = sys.props("dotty.tests.classes.compiler")
+  /** dotty-interfaces jar */
+  def dottyInterfaces: String = sys.props("dotty.tests.classes.dottyInterfaces")
 
-  /** Dotty classpath extras provided through define */
-  def dottyExtras: List[String] =
-    Option(sys.props("dotty.tests.extraclasspath"))
-      .map(_.split(":").toList)
-      .getOrElse(Nil)
+  /** dotty-library jar */
+  def dottyLibrary: String = sys.props("dotty.tests.classes.dottyLibrary")
 
-  /** Dotty interfaces path provided through define */
-  def dottyInterfaces: String = sys.props("dotty.tests.classes.interfaces")
+  /** dotty-compiler jar */
+  def dottyCompiler: String = sys.props("dotty.tests.classes.dottyCompiler")
 
-  /** Dotty library path provided through define */
-  def dottyLib: String = sys.props("dotty.tests.classes.library")
+  /** compiler-interface jar */
+  def compilerInterface: String = sys.props("dotty.tests.classes.compilerInterface")
+
+  /** scala-library jar */
+  def scalaLibrary: String = sys.props("dotty.tests.classes.scalaLibrary")
+
+  /** scala-asm jar */
+  def scalaAsm: String = sys.props("dotty.tests.classes.scalaAsm")
+
+  /** scala-xml jar */
+  def scalaXml: String = sys.props("dotty.tests.classes.scalaXml")
+
+  /** jline-terminal jar */
+  def jlineTerminal: String = sys.props("dotty.tests.classes.jlineTerminal")
+
+  /** jline-reader jar */
+  def jlineReader: String = sys.props("dotty.tests.classes.jlineReader")
 }

compiler/test/dotty/Properties.scala

@@ -1,6 +1,8 @@
 package dotty
 package tools
 
+import vulpix.TestConfiguration
+
 import dotc.core._
 import dotc.core.Comments.{ContextDoc, ContextDocstrings}
 import dotc.core.Contexts._
@@ -39,7 +41,7 @@ trait DottyTest extends ContextEscapeDetection {
 
   protected def initializeCtx(fc: FreshContext): Unit = {
     fc.setSetting(fc.settings.encoding, "UTF8")
-    fc.setSetting(fc.settings.classpath, Jars.dottyLib)
+    fc.setSetting(fc.settings.classpath, TestConfiguration.basicClasspath)
     fc.setProperty(ContextDoc, new ContextDocstrings)
   }
 

compiler/test/dotty/tools/DottyTest.scala

@@ -2,6 +2,8 @@ package dotty
 package tools
 package backend.jvm
 
+import vulpix.TestConfiguration
+
 import dotc.core.Contexts.{Context, ContextBase}
 import dotc.core.Comments.{ContextDoc, ContextDocstrings}
 import dotc.core.Phases.Phase
@@ -44,7 +46,7 @@ trait DottyBytecodeTest {
   def initCtx = {
     val ctx0 = (new ContextBase).initialCtx.fresh
     val outputDir = new VirtualDirectory("<DottyBytecodeTest output>")
-    ctx0.setSetting(ctx0.settings.classpath, Jars.dottyLib)
+    ctx0.setSetting(ctx0.settings.classpath, TestConfiguration.basicClasspath)
     ctx0.setProperty(ContextDoc, new ContextDocstrings)
     ctx0.setSetting(ctx0.settings.outputDir, outputDir)
   }

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTest.scala

@@ -33,56 +33,56 @@ class BootstrappedOnlyCompilationTests extends ParallelTesting {
 
   @Test def posWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compilePosWithCompiler")
-    compileFilesInDir("tests/pos-with-compiler", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/ast", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/config", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/core", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/transform", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/parsing", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/printing", defaultOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/reporting", defaultOptions) +
-    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))
+    compileFilesInDir("tests/pos-with-compiler", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/ast", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/config", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/core", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/transform", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/parsing", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/printing", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/reporting", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/typer", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/util", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/io", withCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/core", withCompilerOptions)
   }.checkCompile()
 
   @Test def posTwiceWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("posTwiceWithCompiler")
-    compileFile("tests/pos-with-compiler/Labels.scala", defaultOptions) +
-    compileFile("tests/pos-with-compiler/Patterns.scala", defaultOptions) +
+    compileFile("tests/pos-with-compiler/Labels.scala", withCompilerOptions) +
+    compileFile("tests/pos-with-compiler/Patterns.scala", withCompilerOptions) +
     compileList(
       "testNonCyclic",
       List(
         "compiler/src/dotty/tools/dotc/CompilationUnit.scala",
         "compiler/src/dotty/tools/dotc/core/Types.scala",
         "compiler/src/dotty/tools/dotc/ast/Trees.scala"
       ),
-      defaultOptions.and("-Xprompt")
+      withCompilerOptions
     ) +
     compileList(
       "testIssue34",
       List(
         "compiler/src/dotty/tools/dotc/config/Properties.scala",
         "compiler/src/dotty/tools/dotc/config/PathResolver.scala"
       ),
-      defaultOptions.and("-Xprompt")
+      withCompilerOptions
     )
   }.times(2).checkCompile()
 
   // Negative tests ------------------------------------------------------------
 
   @Test def negAll: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compileNegWithCompiler")
-    compileFilesInDir("tests/neg-with-compiler", defaultOptions)
+    compileFilesInDir("tests/neg-with-compiler", withCompilerOptions)
   }.checkExpectedErrors()
 
   // Run tests -----------------------------------------------------------------
 
   @Test def runWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("runWithCompiler")
-    compileFilesInDir("tests/run-with-compiler", defaultRunWithCompilerOptions) +
-    compileFile("tests/run-with-compiler-custom-args/staged-streams_1.scala", defaultRunWithCompilerOptions without "-Yno-deep-subtypes")
+    compileFilesInDir("tests/run-with-compiler", withCompilerOptions) +
+    compileFile("tests/run-with-compiler-custom-args/staged-streams_1.scala", withCompilerOptions without "-Yno-deep-subtypes")
   }.checkRuns()
 
   // Pickling Tests ------------------------------------------------------------
@@ -92,24 +92,24 @@ class BootstrappedOnlyCompilationTests extends ParallelTesting {
 
   @Test def picklingWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("testPicklingWithCompiler")
-    compileDir("compiler/src/dotty/tools", picklingOptions, recursive = false) +
-    compileDir("compiler/src/dotty/tools/dotc", picklingOptions, recursive = false) +
-    compileDir("library/src/dotty/runtime", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/backend/jvm", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/ast", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/core", picklingOptions, recursive = false) +
-    compileDir("compiler/src/dotty/tools/dotc/config", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/parsing", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/printing", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/repl", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/rewrite", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/transform", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/typer", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/util", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/io", picklingOptions) +
-    compileFile("tests/pos/pickleinf.scala", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/core/classfile", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/core/tasty", picklingOptions) +
-    compileDir("compiler/src/dotty/tools/dotc/core/unpickleScala2", picklingOptions)
+    compileDir("compiler/src/dotty/tools", picklingWithCompilerOptions, recursive = false) +
+    compileDir("compiler/src/dotty/tools/dotc", picklingWithCompilerOptions, recursive = false) +
+    compileDir("library/src/dotty/runtime", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/backend/jvm", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/ast", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/core", picklingWithCompilerOptions, recursive = false) +
+    compileDir("compiler/src/dotty/tools/dotc/config", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/parsing", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/printing", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/repl", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/rewrite", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/transform", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/typer", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/util", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/io", picklingWithCompilerOptions) +
+    compileFile("tests/pos/pickleinf.scala", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/core/classfile", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/core/tasty", picklingWithCompilerOptions) +
+    compileDir("compiler/src/dotty/tools/dotc/core/unpickleScala2", picklingWithCompilerOptions)
   }.limitThreads(4).checkCompile()
 }

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

@@ -204,8 +204,9 @@ class CompilationTests extends ParallelTesting {
       defaultOutputDir + libGroup + "/src/:" +
       // as well as bootstrapped compiler:
       defaultOutputDir + dotty1Group + "/dotty/:" +
-      // and the other compiler dependecies:
-      Jars.dottyInterfaces + ":" + Jars.jlineTerminal + ":" + Jars.jlineReader,
+      // and the other compiler dependenies:
+      Properties.compilerInterface + ":" + Properties.scalaLibrary + ":" + Properties.scalaAsm + ":" +
+      Properties.dottyInterfaces + ":" + Properties.jlineTerminal + ":" + Properties.jlineReader,
       Array("-Ycheck-reentrant", "-Yemit-tasty-in-class")
     )
 
@@ -277,7 +278,7 @@ class CompilationTests extends ParallelTesting {
         val compileDir = createOutputDirsForDir(dir, sourceDir, outDir)
         import java.nio.file.StandardCopyOption.REPLACE_EXISTING
         Files.copy(dir.toPath.resolve(pluginFile), compileDir.toPath.resolve(pluginFile), REPLACE_EXISTING)
-        val flags = TestFlags(classPath, noCheckOptions) and ("-Xplugin:" + compileDir.getAbsolutePath)
+        val flags = TestFlags(withCompilerClasspath, noCheckOptions) and ("-Xplugin:" + compileDir.getAbsolutePath)
         SeparateCompilationSource("testPlugins", dir, flags, compileDir)
       }
 

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

@@ -5,12 +5,12 @@ package dotc
 import org.junit.Test
 import org.junit.Assert._
 
-import vulpix.TestConfiguration.mkClassPath
+import vulpix.TestConfiguration.mkClasspath
 
 class MissingCoreLibTests {
 
   @Test def missingDottyLib: Unit = {
-    val classPath = mkClassPath(Jars.dottyCompiler :: Jars.dottyInterfaces :: Jars.dottyExtras) // missing Jars.dottyLib
+    val classPath = mkClasspath(List(Properties.scalaLibrary)) // missing Properties.dottyLibrary
     val source = "tests/pos/Foo.scala"
     val options = Array("-classpath", classPath, source)
     val reporter = Main.process(options)

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

@@ -1,12 +1,14 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
+
+import vulpix.TestConfiguration
 
 import org.junit.Test
 import org.junit.Assert._
 
 import java.nio.file._
 
-import dotty.Jars
-import dotty.tools.vulpix.TestConfiguration.mkClassPath
+import dotty.tools.vulpix.TestConfiguration.mkClasspath
 
 class SettingsTests {
 
@@ -18,11 +20,10 @@ class SettingsTests {
   }
 
   @Test def jarOutput: Unit = {
-    val classPath = mkClassPath(Jars.dottyTestDeps)
     val source = "tests/pos/Foo.scala"
     val out = Paths.get("out/jaredFoo.jar").normalize
     if (Files.exists(out)) Files.delete(out)
-    val options = Array("-classpath", classPath, "-d", out.toString, source)
+    val options = Array("-classpath", TestConfiguration.basicClasspath, "-d", out.toString, source)
     val reporter = Main.process(options)
     assertEquals(0, reporter.errorCount)
     assertTrue(Files.exists(out))

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

@@ -3,6 +3,8 @@ package tools
 package dotc
 package transform
 
+import vulpix.TestConfiguration
+
 import java.io._
 import java.nio.file.{Path => JPath}
 
@@ -15,7 +17,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", "-classpath", TestConfiguration.basicClasspath)
 
   private def compileFile(path: JPath) = {
     val stringBuffer = new StringWriter()

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

@@ -1,14 +1,16 @@
-package dotty.tools.repl
+package dotty.tools
+package repl
+
+import vulpix.TestConfiguration
 
 import java.io.{ByteArrayOutputStream, PrintStream}
 
-import dotty.Jars
 import dotty.tools.dotc.reporting.MessageRendering
 import org.junit.{After, Before}
 
 
 class ReplTest private (out: ByteArrayOutputStream) extends ReplDriver(
-  Array("-classpath", List(Jars.dottyLib, Jars.dottyInterfaces).mkString(":"), "-color:never"),
+  Array("-classpath", TestConfiguration.basicClasspath, "-color:never"),
   new PrintStream(out)
 ) with MessageRendering {