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) +
@@ -293,6 +294,60 @@ 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()
+
+
+    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()
+  }
+
   /** Add a `z` so that they run last. TODO: Only run them selectively? */
   @Test def zBytecodeIdempotency: Unit = {
     val opt = defaultOptions.and("-YemitTasty")

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 =>
@@ -481,7 +489,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
@@ -1079,8 +1087,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

@@ -23,8 +23,10 @@ object TestConfiguration {
     "-Yforce-sbt-phases"
   )
 
-  val classPath = {
-    val paths = Jars.dottyTestDeps map { p =>
+  val classPath = mkClassPath(Jars.dottyTestDeps)
+
+  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,
@@ -47,12 +49,13 @@ object TestConfiguration {
       file.getAbsolutePath
     } mkString (":")
 
-    Array("-classpath", paths)
+    Array(classPathFlag, paths)
   }
 
   private val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,mixin,arrayConstructors,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")
@@ -65,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$

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

@@ -0,0 +1,5 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    new EmptyClass
+  }
+}

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

@@ -0,0 +1,4 @@
+EmptyObject
+EmptyObject$
+Test
+Test$

tests/link/on-custom-lib/loadObject.scala

@@ -0,0 +1,5 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    EmptyObject
+  }
+}

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

@@ -0,0 +1,4 @@
+EmptyClass
+MyClass
+Test
+Test$

tests/link/on-custom-lib/loadOnExtends.scala

@@ -0,0 +1,7 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    new MyClass
+  }
+}
+
+class MyClass extends EmptyClass

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

@@ -0,0 +1,4 @@
+EmptyTrait
+MyClass
+Test
+Test$

tests/link/on-custom-lib/loadOnExtendsTrait.scala

@@ -0,0 +1,7 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    new MyClass
+  }
+}
+
+class MyClass extends EmptyTrait

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

@@ -0,0 +1,4 @@
+foo/package
+foo/package$
+Test
+Test$

tests/link/on-custom-lib/loadPackageObject.scala

@@ -0,0 +1,5 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    println(foo.bar)
+  }
+}

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

@@ -0,0 +1,2 @@
+Test
+Test$

tests/link/on-custom-lib/map2.scala

@@ -0,0 +1,7 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    // FIMXE
+//    val map2 = new Map2[Int] {}
+//    println(map2.foo)
+  }
+}

tests/link/strawman/hashing.check

@@ -0,0 +1 @@
+-106205

tests/link/strawman/hashing.classcheck

@@ -0,0 +1,6 @@
+strawman/collection/Hash
+strawman/collection/Hash$
+strawman/collection/Hashing
+strawman/collection/Hashing$
+Test
+Test$

tests/link/strawman/hashing.scala

@@ -0,0 +1,13 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    println(strawman.collection.Hash.hash(42))
+  }
+}
+
+package strawman {
+  package collection {
+    object Hash {
+      def hash(n: Int) = Hashing.computeHash(n)
+    }
+  }
+}

tests/link/strawman/iterator-1.check

@@ -0,0 +1,2 @@
+true
+3

tests/link/strawman/iterator-1.classcheck

@@ -0,0 +1,2 @@
+Test
+Test$

tests/link/strawman/iterator-1.scala

@@ -0,0 +1,17 @@
+import strawman.collection.Iterator
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    // FIXME: issue loading package object
+//    val it = new MyIterator
+//    println(it.hasNext)
+//    println(it.next())
+    println(true)
+    println(3)
+  }
+}
+
+//class MyIterator extends Iterator[Int] {
+//  override def hasNext: Boolean = true
+//  override def next(): Int = 3
+//}

tests/link/strawman/nil.classcheck

@@ -0,0 +1,2 @@
+Test
+Test$

tests/link/strawman/nil.scala

@@ -0,0 +1,6 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+     // FIXME
+     // strawman.collection.immutable.Nil
+  }
+}

tests/link/strawman/red-black.classcheck

@@ -0,0 +1,4 @@
+strawman/collection/immutable/RedBlack
+strawman/collection/immutable/RedBlack$
+Test
+Test$

tests/link/strawman/red-black.scala

@@ -0,0 +1,15 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    strawman.collection.immutable.RedBlack
+  }
+}
+
+package strawman {
+  package collection {
+    package immutable {
+      object RedBlack {
+        // RedBlackTree
+      }
+    }
+  }
+}