Add link tests

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/dotty/tools/dotc/CompilationTests.scala

@@ -3,6 +3,7 @@ package tools
 package dotc
 
 import org.junit.{ Test, BeforeClass, AfterClass }
+import org.junit.Assert._
 
 import java.nio.file._
 import java.util.stream.{ Stream => JStream }
@@ -11,6 +12,7 @@ import scala.util.matching.Regex
 import scala.concurrent.duration._
 
 import vulpix.{ ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration }
+import dotty.tools.io.JFile
 
 
 class CompilationTests extends ParallelTesting {
@@ -29,7 +31,6 @@ class CompilationTests extends ParallelTesting {
 
   @Test def compilePos: Unit = {
     compileList("compileStdLib", StdLibSources.whitelisted, scala2Mode.and("-migration", "-Yno-inline")) +
-    compileDir("../collection-strawman/src/main", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/ast", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/config", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/core", allowDeepSubtypes) +
@@ -292,6 +293,79 @@ class CompilationTests extends ParallelTesting {
 
     tests.foreach(_.delete())
   }
+
+  @Test def linkAll: Unit = {
+    // Setup and compile libraries
+    def strawmanLibrary =
+      compileDir("../collection-strawman/src/main", defaultOptions)
+    def linkCustomLib =
+      compileDir("../tests/link/custom-lib", defaultOptions)
+
+    val libraries = {
+      strawmanLibrary +
+      linkCustomLib
+    }.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")
+
+    // 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 classFileChecks(sourceDir: String, testName: String) = {
+      val checkExt = ".classcheck"
+      for (check <- new JFile(sourceDir).listFiles().filter(_.toString.endsWith(checkExt))) {
+        val outDir = {
+          def path(str: String) = str.substring(linkDir.length, str.length - checkExt.length)
+          defaultOutputDir + testName + path(check.toString) + "/"
+        }
+        val expectedClasses = scala.io.Source.fromFile(check).getLines().toSet
+        val actualClasses = Files.walk(Paths.get(outDir)).iterator().asScala.collect {
+          case f if f.toString.endsWith(".class") => f.toString.substring(outDir.length, f.toString.length - ".class".length)
+        }.toSet
+        assertEquals(check.toString, expectedClasses, actualClasses)
+      }
+    }
+
+    // Run all tests
+    val tests = {
+      linkStrawmanTest +
+      linkCustomLibTest
+    }.keepOutput.checkRuns()
+
+    classFileChecks(linkStramanDir, "linkStrawmanTest")
+    classFileChecks(linkCustomLibDir, "linkCustomLibTest")
+
+    (libraries + tests).delete()
+  }
+
+  private val (compilerSources, backendSources, backendJvmSources) = {
+    val compilerDir = Paths.get("../compiler/src")
+    val compilerSources0 = sources(Files.walk(compilerDir))
+
+    val backendDir = Paths.get("../scala-backend/src/compiler/scala/tools/nsc/backend")
+    val backendJvmDir = Paths.get("../scala-backend/src/compiler/scala/tools/nsc/backend/jvm")
+
+    // NOTE: Keep these exclusions synchronized with the ones in the sbt build (Build.scala)
+    val backendExcluded =
+      List("JavaPlatform.scala", "Platform.scala", "ScalaPrimitives.scala")
+    val backendJvmExcluded =
+      List("BCodeICodeCommon.scala", "GenASM.scala", "GenBCode.scala", "ScalacBackendInterface.scala", "BackendStats.scala")
+
+    val backendSources0 =
+      sources(Files.list(backendDir), excludedFiles = backendExcluded)
+    val backendJvmSources0 =
+      sources(Files.list(backendJvmDir), excludedFiles = backendJvmExcluded)
+
+    (compilerSources0, backendSources0, backendJvmSources0)
+  }
 }
 
 object CompilationTests {

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

@@ -61,6 +61,14 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         .map(":" + _)
         .getOrElse("")
 
+    def runClassPath = {
+      flags
+        .dropWhile(_ != "-YRunClasspath")
+        .drop(1)
+        .headOption
+        .map(outDir.getAbsolutePath + ":" + _)
+        .getOrElse(classPath)
+    }
 
     def title: String = self match {
       case self: JointCompilationSource =>
@@ -503,7 +511,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
     private def verifyOutput(checkFile: Option[JFile], dir: JFile, testSource: TestSource, warnings: Int) = {
       if (Properties.testsNoRun) addNoRunWarning()
-      else runMain(testSource.classPath) match {
+      else runMain(testSource.runClassPath) match {
         case Success(_) if !checkFile.isDefined || !checkFile.get.exists => // success!
         case Success(output) => {
           val outputLines = output.lines.toArray
@@ -1124,8 +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: Array[String])(implicit outDirectory: String): CompilationTest = {
-    val callingMethod = getCallingMethod()
+  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`:

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

@@ -25,8 +25,8 @@ object TestConfiguration {
 
   val classPath = mkClassPath(Jars.dottyTestDeps)
 
-  def mkClassPath(deps: List[String]): Array[String] = {
-    val paths = deps 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,
@@ -49,12 +49,13 @@ object TestConfiguration {
       file.getAbsolutePath
     } mkString (":")
 
-    Array("-classpath", paths)
+    Array(classPathFlag, paths)
   }
 
   val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,erasure,mixin,getClass,restoreScopes,labelDef")
 
-  val defaultUnoptimised = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath
+  val basicDefaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions
+  val defaultUnoptimised = basicDefaultOptions ++ classPath
   val defaultOptimised = defaultUnoptimised :+ "-optimise"
   val defaultOptions = defaultUnoptimised
   val allowDeepSubtypes = defaultOptions diff Array("-Yno-deep-subtypes")
@@ -67,4 +68,5 @@ object TestConfiguration {
   val scala2Mode = defaultOptions ++ Array("-language:Scala2")
   val explicitUTF8 = defaultOptions ++ Array("-encoding", "UTF8")
   val explicitUTF16 = defaultOptions ++ Array("-encoding", "UTF16")
+  val basicLinkOptimise = basicDefaultOptions ++ Array("-Xlink-optimise")
 }

tests/link/custom-lib/EmptyClass.scala

@@ -0,0 +1 @@
+class EmptyClass

tests/link/custom-lib/EmptyObject.scala

@@ -0,0 +1 @@
+object EmptyObject

tests/link/custom-lib/EmptyTrait.scala

@@ -0,0 +1 @@
+trait EmptyTrait

tests/link/custom-lib/Map2.scala

@@ -0,0 +1,9 @@
+trait Map2[K] {
+  def get(k: K): K = k
+  def foo: K = {
+    this match {
+      case that: Map2[b] => that.get(3.asInstanceOf[b])
+      case _ => get(5.asInstanceOf[K])
+    }
+  }
+}

tests/link/custom-lib/foo/package.scala

@@ -0,0 +1,3 @@
+package object foo {
+  def bar = 42
+}

tests/link/on-custom-lib/loadClass.classcheck

@@ -0,0 +1,3 @@
+EmptyClass
+Test
+Test$