Merge pull request #540 from dwijnand/pre-tweaks

Tweaks in prep for the mixin static forwarders fix

Author: dwijnand

build.sbt

@@ -73,6 +73,8 @@ val functionalTests = Project("functional-tests", file("functional-tests"))
     testFrameworks += new TestFramework("munit.Framework"),
     //Test / run / fork := true,
     //Test / run / forkOptions := (Test / run / forkOptions).value.withWorkingDirectory((ThisBuild / baseDirectory).value),
+    // Test / testOnly / watchTriggers += baseDirectory.value.toGlob / "src" / "test" / **,
+    // ^ disabled b/c of "Build triggered by [..]/target/scala-2.12/v2-classes."
     testFunctional := (Test / test).value,
     Defaults.itSettings,
     mimaFailOnNoPrevious := false,

core/src/main/scala/com/typesafe/tools/mima/core/ClassInfo.scala

@@ -169,7 +169,7 @@ private[mima] sealed abstract class ClassInfo(val owner: PackageInfo) extends In
     else superClass.allInterfaces ++ interfaces ++ interfaces.flatMap(_.allInterfaces)
   }
 
-  /** Does this implementation class have a static implementation of given method `m`? */
+  /** Does this class's impl class have a static implementation of the given method `m`? */
   final def hasStaticImpl(m: MethodInfo): Boolean = {
     implClass match {
       case _: SyntheticClassInfo   => false

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/AppRunTest.scala

@@ -1,17 +1,15 @@
 package com.typesafe.tools.mima.lib
 
-import com.typesafe.tools.mima.lib.UnitTests._
-
-import scala.util.{ Failure, Success }
+import scala.util.{ Failure, Success, Try }
 
 /** Test running the App, using library v2. */
 object AppRunTest {
   def main(args: Array[String]): Unit = TestCli.argsToTests(args.toList, testAppRun).unsafeRunTest()
 
-  def testAppRun(testCase: TestCase) = for {
+  def testAppRun(testCase: TestCase): Try[Unit] = for {
     () <- testCase.compileThem
     pending = testCase.versionedFile("testAppRun.pending").exists
-    emptyPT = blankFile(testCase.versionedFile("problems.txt"))
+    emptyPT = testCase.blankFile(testCase.versionedFile("problems.txt"))
     () <- testCase.runMain(testCase.outV1) // expect at least v1 to pass, even in the "pending" case
     () <- testCase.runMain(testCase.outV2) match {
       case Failure(t)  if !pending &&  emptyPT => Failure(t)

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/CollectProblemsTest.scala

@@ -11,7 +11,7 @@ import scala.util.{ Failure, Success, Try }
 object CollectProblemsTest {
   def main(args: Array[String]): Unit = TestCli.argsToTests(args.toList, testCollectProblems).unsafeRunTest()
 
-  def testCollectProblems(testCase: TestCase) = for {
+  def testCollectProblems(testCase: TestCase): Try[Unit] = for {
     () <- testCase.compileThem
     problems = collectProblems(testCase.outV1.jfile, testCase.outV2.jfile)
     expected = readOracleFile(testCase.versionedFile("problems.txt").jfile)
@@ -26,26 +26,26 @@ object CollectProblemsTest {
     Files.lines(oracleFile.toPath).iterator.asScala.filter(!_.startsWith("#")).toList
   }
 
-  def diffProblems(problems: List[Problem], expected: List[String]): Try[Unit] = {
+  def diffProblems(problems: List[Problem], expected: List[String], v: String = "new"): Try[Unit] = {
     // diff between the oracle and the collected problems
-    val unexpected = problems.filter(p => !expected.contains(p.description("new")))
-    val unreported = expected.diff(problems.map(_.description("new")))
+    val unexpected = problems.filter(p => !expected.contains(p.description(v)))
+    val unreported = expected.diff(problems.map(_.description(v)))
 
-    val msg = new StringBuilder
+    val msg = new StringBuilder("\n")
     def pp(start: String, lines: List[String]) = {
       if (lines.isEmpty) ()
       else lines.sorted.distinct.addString(msg, s"$start (${lines.size}):\n  - ", "\n  - ", "\n")
     }
     pp("The following problem(s) were expected but not reported", unreported)
-    pp("The following problem(s) were reported but not expected", unexpected.map(_.description("new")))
+    pp("The following problem(s) were reported but not expected", unexpected.map(_.description(v)))
     pp("Filter with:", unexpected.flatMap(_.howToFilter))
     pp("Or filter with:", unexpected.flatMap(p => p.matchName.map { matchName =>
       s"{ matchName=$dq$matchName$dq , problemName=${p.getClass.getSimpleName} }"
     }))
 
     msg.mkString match {
-      case ""  => Success(())
-      case msg => Failure(new Exception(msg))
+      case "\n" => Success(())
+      case msg  => Failure(new Exception(msg))
     }
   }
 

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/TestCase.scala

@@ -1,12 +1,12 @@
 package com.typesafe.tools.mima.lib
 
-import java.io.{ ByteArrayOutputStream, PrintStream }
+import java.io.{ ByteArrayOutputStream, File, PrintStream }
 import java.net.{ URI, URLClassLoader }
 import javax.tools._
 
 import scala.collection.JavaConverters._
 import scala.collection.mutable
-import scala.reflect.internal.util.{ BatchSourceFile, SourceFile }
+import scala.reflect.internal.util.BatchSourceFile
 import scala.reflect.io.{ Directory, Path, PlainFile }
 import scala.util.{ Failure, Success, Try }
 
@@ -25,32 +25,36 @@ final class TestCase(val baseDir: Directory, val scalaCompiler: ScalaCompiler, v
   val outApp = (baseDir / s"target/scala-$scalaBinaryVersion/app-classes").toDirectory
 
   lazy val compileThem: Try[Unit] = for {
-    () <- Try(List(outV1, outV2, outApp).foreach(recreateDir(_)))
-    () <- compileDir(srcV1,  outV1)
-    () <- compileDir(srcApp, outApp)
-    () <- compileDir(srcV2,  outV2)  // run after App, to make sure App links to v1
+    () <- compileV1()
+    () <- compileV2()
+    () <- compileApp(outV1)
   } yield ()
 
-  def compileDir(srcDir: Directory, out: Directory): Try[Unit] = {
-    val sourceFiles = srcDir.files.map(f => new BatchSourceFile(new PlainFile(f))).toList
-    for {
-      () <- compileScala(sourceFiles, out)
-      () <- compileJava(sourceFiles.filter(_.isJava), out)
-    } yield ()
-  }
+  def compileV1()                   = compileDir(srcV1, Nil, outV1)
+  def compileV2()                   = compileDir(srcV2, Nil, outV2)
+  def compileApp(outLib: Directory) = compileDir(srcApp, List(outLib), outApp)
+
+  def compileDir(srcDir: Directory, cp: List[Directory], out: Directory): Try[Unit] = for {
+    () <- Try(recreateDir(out))
+    () <- compileScala(srcDir, cp, out)
+    () <- compileJava(srcDir, cp, out)
+  } yield ()
 
-  def compileScala(sourceFiles: List[SourceFile], out: Directory): Try[Unit] = {
+  def compileScala(srcDir: Directory, cp: List[Directory], out: Directory): Try[Unit] = {
+    val sourceFiles = lsSrcs(srcDir)
     if (sourceFiles.forall(_.isJava)) return Success(())
     val bootcp = ClassPath.join(scalaJars.map(_.getPath))
+    val cpOpt  = if (cp.isEmpty) Nil else List("-cp", ClassPath.join(cp.map(_.path)))
     val paths = sourceFiles.map(_.path)
-    val args = "-bootclasspath" :: bootcp :: "-classpath" :: s"$outV1" :: "-d" :: s"$out" :: paths
+    val args = "-bootclasspath" :: bootcp :: cpOpt ::: "-d" :: s"$out" :: paths
     scalaCompiler.compile(args)
   }
 
-  def compileJava(sourceFiles: List[SourceFile], out: Directory): Try[Unit] = {
+  def compileJava(srcDir: Directory, cp: List[Directory], out: Directory): Try[Unit] = {
+    val sourceFiles = lsSrcs(srcDir, _.hasExtension("java"))
     if (sourceFiles.isEmpty) return Success(())
-    val cp = ClassPath.join((scalaJars :+ outV1.jfile).map(_.getPath))
-    val opts = List("-classpath", cp, "-d", s"$out").asJava
+    val cpStr = ClassPath.join((scalaJars ++ cp.map(_.jfile)).map(_.getPath))
+    val opts = List("-classpath", cpStr, "-d", s"$out").asJava
     val units = sourceFiles.map { sf =>
       new SimpleJavaFileObject(new URI(s"string:///${sf.path}"), JavaFileObject.Kind.SOURCE) {
         override def getCharContent(ignoreEncodingErrors: Boolean) = sf.content
@@ -86,6 +90,12 @@ final class TestCase(val baseDir: Directory, val scalaCompiler: ScalaCompiler, v
     }
   }
 
+  def lsSrcs(dir: Directory, cond: Path => Boolean = _.hasExtension("scala", "java")) = {
+    dir.walkFilter(cond).map(f => new BatchSourceFile(new PlainFile(f))).toList.sortBy(_.path)
+  }
+
+  def blankFile(p: Path): Boolean = p.toFile.lines().forall(_.startsWith("#"))
+
   def versionedFile(path: Path) = {
     val p    = baseDir.resolve(path).toFile
     val p211 = (p.parent / (s"${p.stripExtension}-2.11")).addExtension(p.extension).toFile
@@ -97,10 +107,11 @@ final class TestCase(val baseDir: Directory, val scalaCompiler: ScalaCompiler, v
     }
   }
 
-  def recreateDir(dir: Directory) = {
+  def recreateDir(dir: Directory): Unit = {
     if (dir.exists)
       assert(dir.deleteRecursively(), s"failed to delete $dir")
     dir.createDirectory()
+    ()
   }
 
   override def toString = s"TestCase(baseDir=${baseDir.name}, scalaVersion=${scalaCompiler.version})"

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/TestCli.scala

@@ -15,13 +15,13 @@ object TestCli {
   val allScalaVersions = List(scala211, scala212, scala213)
   val testsDir = Directory("functional-tests/src/test")
 
-  def argsToTests(argv: List[String], runTestCase: TestCase => Try[Unit]): Tests =
-    Tests(fromArgs(argv).map(testCaseToTest1(_, runTestCase)))
+  def argsToTests(args: List[String], runTestCase: TestCase => Try[Unit]): Tests =
+    Tests(fromArgs(args).map(testCaseToTest1(_, runTestCase)))
 
   def testCaseToTest1(tc: TestCase, runTestCase: TestCase => Try[Unit]): Test1 =
     Test(s"${tc.scalaBinaryVersion} / ${tc.name}", runTestCase(tc))
 
-  def fromArgs(argv: List[String]): List[TestCase] = fromConf(go(argv, Conf(Nil, Nil)))
+  def fromArgs(args: List[String]): List[TestCase] = fromConf(go(args, Conf(Nil, Nil)))
 
   @tailrec def postProcessConf(conf: Conf): Conf = conf match {
     case Conf(Nil, _) => postProcessConf(conf.copy(scalaVersions = List(hostScalaVersion)))
@@ -31,13 +31,15 @@ object TestCli {
 
   def fromConf(conf: Conf): List[TestCase] = {
     val conf1 = postProcessConf(conf)
-    val javaCompiler = ToolProvider.getSystemJavaCompiler
+    val javaCompiler = getJavaCompiler
     for {
       sc <- conf1.scalaVersions.map(new ScalaCompiler(_))
       dir <- conf1.dirs
     } yield new TestCase(dir, sc, javaCompiler)
   }
 
+  def getJavaCompiler = ToolProvider.getSystemJavaCompiler
+
   def allTestDirs() = testsDir.dirs.filter(_.files.exists(_.name == "problems.txt")).toList.sortBy(_.path)
 
   final case class Conf(scalaVersions: List[String], dirs: List[Directory])

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/UnitTests.scala

@@ -1,6 +1,5 @@
 package com.typesafe.tools.mima.lib
 
-import scala.reflect.io.Path
 import scala.util.{ Failure, Success, Try }
 
 import munit.GenericTest
@@ -16,13 +15,11 @@ object UnitTests {
   } yield ()
 
   def testNameCheck(testCase: TestCase): Try[Unit] = {
-    val emptyProblemsTxt = blankFile(testCase.baseDir / "problems.txt")
+    val emptyProblemsTxt = testCase.blankFile(testCase.baseDir / "problems.txt")
     testCase.baseDir.name.takeRight(4).dropWhile(_ != '-') match {
       case "-ok"  => if (emptyProblemsTxt) Success(()) else Failure(new Exception("OK test with non-empty problems.txt"))
       case "-nok" => if (emptyProblemsTxt) Failure(new Exception("NOK test with empty problems.txt")) else Success(())
       case _      => Failure(new Exception("Missing '-ok' or '-nok' suffix in project name"))
     }
   }
-
-  def blankFile(p: Path): Boolean = p.toFile.lines().forall(_.startsWith("#"))
 }