Fix scala#2185: Add bytecode idempotency checks.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala

@@ -14,7 +14,7 @@ import Decorators._
 class TastyPickler {
 
   private val sections = new mutable.ArrayBuffer[(NameRef, TastyBuffer)]
-  val uuid = UUID.randomUUID()
+  private val uuid = UUID.fromString("3cee1b79-c03a-4125-b337-d067b5cb3a94") // TODO: use a hash of the tasty tree
 
   private val headerBuffer = {
     val buf = new TastyBuffer(24)

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

@@ -5,6 +5,7 @@ package dotc
 import org.junit.{ Test, BeforeClass, AfterClass }
 
 import java.nio.file._
+import java.io.{ File => JFile }
 import java.util.stream.{ Stream => JStream }
 import scala.collection.JavaConverters._
 import scala.util.matching.Regex
@@ -231,30 +232,6 @@ class CompilationTests extends ParallelTesting {
       compileDir("../library/src",
         allowDeepSubtypes.and("-Ycheck-reentrant", "-strict", "-priorityclasspath", defaultOutputDir))
 
-    def sources(paths: JStream[Path], excludedFiles: List[String] = Nil): List[String] =
-      paths.iterator().asScala
-        .filter(path =>
-          (path.toString.endsWith(".scala") || path.toString.endsWith(".java"))
-            && !excludedFiles.contains(path.getFileName.toString))
-        .map(_.toString).toList
-
-    val compilerDir = Paths.get("../compiler/src")
-    val compilerSources = 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")
-
-    val backendSources =
-      sources(Files.list(backendDir), excludedFiles = backendExcluded)
-    val backendJvmSources =
-      sources(Files.list(backendJvmDir), excludedFiles = backendJvmExcluded)
-
     def dotty1 = {
       compileList(
         "dotty1",
@@ -285,6 +262,115 @@ class CompilationTests extends ParallelTesting {
       } :: Nil
     }.map(_.checkCompile()).foreach(_.delete())
   }
+
+  @Test def bytecodeIdemporency: Unit = {
+    var failed = 0
+    var total = 0
+    val blacklisted = Set(
+      "pos/Map/scala/collection/immutable/Map",
+      "pos/Map/scala/collection/immutable/AbstractMap",
+      "pos/t1203a/NodeSeq"
+    )
+    def checkIdempotency(): Unit = {
+      def listFilesIn(i: Int) = {
+        def getListOfFiles(file: JFile): List[JFile] =
+          if (file.isDirectory) file.listFiles.flatMap(getListOfFiles).toList
+          else if (file.toString.endsWith(".class") || file.toString.endsWith(".tasty")) List(file)
+          else Nil
+        getListOfFiles(new JFile(s"../out/idempotency$i"))
+      }
+
+      def groupedFiles: List[(JFile, JFile, JFile, JFile)] = {
+        val files = listFilesIn(1) ++ listFilesIn(2)
+        val groups = files.groupBy(f => f.toString.substring("../out/idempotencyN/".length, f.toString.length - 6))
+        groups.filterNot(x => blacklisted(x._1)).valuesIterator.flatMap { g =>
+          def pred(f: JFile, i: Int, tasty: Boolean) =
+            f.toString.contains("idempotency" + i) && f.toString.endsWith(if (tasty) ".tasty" else ".class")
+          val class1 = g.find(f => pred(f, 1, false))
+          val class2 = g.find(f => pred(f, 2, false))
+          val tasty1 = g.find(f => pred(f, 1, true))
+          val tasty2 = g.find(f => pred(f, 2, true))
+          assert(class1.isDefined, "Could not find class in idempotency1 for " + class2)
+          assert(class2.isDefined, "Could not find class in idempotency2 for " + class1)
+          if (tasty1.isEmpty || tasty2.isEmpty) Nil
+          else List(Tuple4(class1.get, tasty1.get, class2.get, tasty2.get))
+        }.toList
+      }
+
+      for ((class1, tasty1, class2, tasty2) <- groupedFiles) {
+        total += 1
+        val bytes1 = Files.readAllBytes(class1.toPath)
+        val bytes2 = Files.readAllBytes(class2.toPath)
+        if (!java.util.Arrays.equals(bytes1, bytes2)) {
+          failed += 1
+          val tastyBytes1 = Files.readAllBytes(tasty1.toPath)
+          val tastyBytes2 = Files.readAllBytes(tasty2.toPath)
+          if (java.util.Arrays.equals(tastyBytes1, tastyBytes2))
+            println(s"Idempotency test failed between $class1 and $class1 (same tasty)")
+          else
+            println(s"Idempotency test failed between $tasty1 and $tasty2")
+          /* Dump bytes to console, could be useful if issue only appears in CI.
+           * Create the .class locally with Files.write(path, Array[Byte](...)) with the printed array
+           */
+          // println(bytes1.mkString("Array[Byte](", ",", ")"))
+          // println(bytes2.mkString("Array[Byte](", ",", ")"))
+        }
+      }
+    }
+
+    val opt = defaultOptions.and("-YemitTasty")
+
+    def idempotency1() = {
+      compileList("dotty1", compilerSources ++ backendSources ++ backendJvmSources, opt) +
+      compileFilesInDir("../tests/pos", opt)
+    }
+    def idempotency2() = {
+      compileList("dotty1", compilerSources ++ backendSources ++ backendJvmSources, opt) +
+      compileFilesInDir("../tests/pos", opt)
+    }
+
+    val tests = (idempotency1() + idempotency2()).keepOutput.checkCompile()
+
+    assert(new java.io.File("../out/idempotency1/").exists)
+    assert(new java.io.File("../out/idempotency2/").exists)
+
+    val t0 = System.currentTimeMillis()
+    checkIdempotency()
+    println(s"checked bytecode idempotency (${(System.currentTimeMillis() - t0) / 1000.0} sec)")
+
+    tests.delete()
+
+    assert(failed == 0, s"Failed $failed idempotency checks (out of $total)")
+  }
+
+
+  private val (compilerSources, backendSources, backendJvmSources) = {
+    def sources(paths: JStream[Path], excludedFiles: List[String] = Nil): List[String] =
+      paths.iterator().asScala
+        .filter(path =>
+          (path.toString.endsWith(".scala") || path.toString.endsWith(".java"))
+            && !excludedFiles.contains(path.getFileName.toString))
+        .map(_.toString).toList
+
+    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")
+
+    val backendSources0 =
+      sources(Files.list(backendDir), excludedFiles = backendExcluded)
+    val backendJvmSources0 =
+      sources(Files.list(backendJvmDir), excludedFiles = backendJvmExcluded)
+
+    (compilerSources0, backendSources0, backendJvmSources0)
+  }
 }
 
 object CompilationTests {