WIP Compile decompiled code

Author: nicolasstucki

compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala

@@ -24,7 +24,7 @@ class DecompilationPrinter extends Phase {
       var os: OutputStream = null
       var ps: PrintStream = null
       try {
-        os = File(outputDir + ".decompiled").outputStream(append = true)
+        os = File(outputDir + "/decompiled.scala").outputStream(append = true)
         ps = new PrintStream(os)
         printToOutput(ps)
       } finally {
@@ -38,21 +38,15 @@ class DecompilationPrinter extends Phase {
     val unit = ctx.compilationUnit
     val pageWidth = ctx.settings.pageWidth.value
     val printLines = ctx.settings.printLines.value
-    val doubleLine = "=" * pageWidth
-    val line = "-" * pageWidth
-
-    out.println(doubleLine)
-    out.println(unit.source)
-    out.println(line)
 
+    out.println(s"/** Decompiled from $unit */")
     val printer = new DecompilerPrinter(ctx)
-
     out.println(printer.toText(unit.tpdTree).mkString(pageWidth, printLines))
-    out.println(line)
 
     if (ctx.settings.printTasty.value) {
+      out.println("/*")
       new TastyPrinter(unit.pickled.head._2).printContents()
-      out.println(line)
+      out.println("*/")
     }
   }
 }

compiler/src/dotty/tools/dotc/decompiler/Main.scala

@@ -14,13 +14,14 @@ object Main extends dotc.Driver {
     assert(ctx.settings.fromTasty.value)
     val outputDir = ctx.settings.outputDir.value
     if (outputDir != ".")
-      Files.deleteIfExists(Paths.get(outputDir + ".decompiled"))
+      Files.deleteIfExists(Paths.get(outputDir + "/decompiled.scala"))
     new TASTYDecompiler
   }
 
   override def setup(args0: Array[String], rootCtx: Context): (List[String], Context) = {
     var args = args0.filter(a => a != "-decompile")
-    args = if (args.contains("-from-tasty")) args else "-from-tasty" +: args
+    if (!args.contains("-from-tasty")) args = "-from-tasty" +: args
+    if (args.contains("-d")) args = "-color:never" +: args
     super.setup(args, rootCtx)
   }
 }

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

@@ -26,7 +26,7 @@ class FromTastyTests extends ParallelTesting {
     // > dotc -Ythrough-tasty -Ycheck:all <source>
 
     implicit val testGroup: TestGroup = TestGroup("posTestFromTasty")
-    val (step1, step2, step3) = compileTastyInDir("tests/pos", defaultOptions,
+    val (step1, step2, step3, step4) = compileTastyInDir("tests/pos2", defaultOptions,
       blacklist = Set(
         "macro-deprecate-dont-touch-backquotedidents.scala",
         "t247.scala",
@@ -67,7 +67,8 @@ class FromTastyTests extends ParallelTesting {
     step1.checkCompile() // Compile all files to generate the class files with tasty
     step2.checkCompile() // Compile from tasty
     step3.checkCompile() // Decompile from tasty
-    (step1 + step2 + step3).delete()
+    step4.checkCompile() // Recompile decompiled code
+    (step1 + step2 + step3 + step4).delete()
   }
 
   @Test def runTestFromTasty: Unit = {
@@ -77,7 +78,7 @@ class FromTastyTests extends ParallelTesting {
     // > dotr Test
 
     implicit val testGroup: TestGroup = TestGroup("runTestFromTasty")
-    val (step1, step2, step3) = compileTastyInDir("tests/run", defaultOptions,
+    val (step1, step2, step3, step4) = compileTastyInDir("tests/run", defaultOptions,
        blacklist = Set(
 
          "t7223.scala",
@@ -112,7 +113,8 @@ class FromTastyTests extends ParallelTesting {
     step1.checkCompile() // Compile all files to generate the class files with tasty
     step2.checkRuns() // Compile from tasty and run the result
     step3.checkCompile() // Decompile from tasty
-    (step1 + step2 + step3).delete()
+    step4.checkCompile() // Recompile decompiled code
+    (step1 + step2 + step3 + step4).delete()
   }
 
   private implicit class tastyCompilationTuples(tup: (CompilationTest, CompilationTest)) {

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

@@ -422,16 +422,17 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       reporter
     }
 
-    protected def decompile(flags0: TestFlags, suppressErrors: Boolean, targetDir: JFile): TestReporter = {
-      val decompilationOutput = new JFile(targetDir.getPath)
-      decompilationOutput.mkdir()
+    protected def decompile(flags0: TestFlags, suppressErrors: Boolean, targetDir0: JFile): TestReporter = {
+      val targetDir = new JFile(targetDir0.getParent + "_decompiled")
+      val decompilationOutput = new JFile(targetDir + "/" + targetDir0.getName)
+      decompilationOutput.mkdirs()
       val flags =
         flags0 and ("-d", decompilationOutput.getAbsolutePath) and
         "-decompile" and "-pagewidth" and "80"
 
       def hasTastyFileToClassName(f: JFile): String =
-        targetDir.toPath.relativize(f.toPath).toString.dropRight(".hasTasty".length).replace('/', '.')
-      val classes = flattenFiles(targetDir).filter(isHasTastyFile).map(hasTastyFileToClassName).sorted
+        targetDir0.toPath.relativize(f.toPath).toString.dropRight(".hasTasty".length).replace('/', '.')
+      val classes = flattenFiles(targetDir0).filter(isHasTastyFile).map(hasTastyFileToClassName).sorted
 
       val reporter =
         TestReporter.reporter(realStdout, logLevel =
@@ -519,7 +520,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
                 checkFileOpt match {
                   case Some(checkFile) =>
                     val stripTrailingWhitespaces = "(.*\\S|)\\s+".r
-                    val output = Source.fromFile(outDir + ".decompiled").getLines().map {line =>
+                    val output = Source.fromFile(outDir.getParent + "_decompiled/" + outDir.getName + "/decompiled.scala").getLines().map {line =>
                       stripTrailingWhitespaces.unapplySeq(line).map(_.head).getOrElse(line)
                     }.mkString("\n")
 
@@ -1260,7 +1261,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
    *  Both testsRequires explicit delete().
    */
   def compileTastyInDir(f: String, flags0: TestFlags, blacklist: Set[String] = Set.empty)(
-      implicit testGroup: TestGroup): (CompilationTest, CompilationTest, CompilationTest) = {
+      implicit testGroup: TestGroup): (CompilationTest, CompilationTest, CompilationTest, CompilationTest) = {
     val outDir = defaultOutputDir + testGroup + "/"
     val flags = flags0 and "-Yretain-trees"
     val sourceDir = new JFile(f)
@@ -1286,10 +1287,14 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     // Create a CompilationTest and let the user decide whether to execute a pos or a neg test
     val generateClassFiles = compileFilesInDir(f, flags0, blacklist)
 
+    val decompilationDir = outDir + sourceDir.getName + "_decompiled"
+    val recompileDecompiled = compileFilesInDir(decompilationDir, flags0, blacklist)
+
     (
       generateClassFiles.keepOutput,
       new CompilationTest(targets).keepOutput,
-      new CompilationTest(targets2).keepOutput
+      new CompilationTest(targets2).keepOutput,
+      recompileDecompiled.keepOutput
     )
   }
 

tests/pos/lambda.decompiled

@@ -1,12 +1,9 @@
-================================================================================
-out/posTestFromTasty/pos/lambda/foo/Foo.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/lambda/foo/Foo.class */
 package foo {
   class Foo() {
     val a: Int => Int =
       {
         (x: Int) => x.*(x)
       }
   }
-}
---------------------------------------------------------------------------------
+}

tests/pos/methodTypes.decompiled

@@ -1,9 +1,6 @@
-================================================================================
-out/posTestFromTasty/pos/methodTypes/Foo.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/methodTypes/Foo.class */
 class Foo() {
   val x: Int = 1
   def y: Int = 2
   def z(): Int = 3
-}
---------------------------------------------------------------------------------
+}

tests/pos/simpleCaseObject.decompiled

@@ -1,6 +1,4 @@
-================================================================================
-out/posTestFromTasty/pos/simpleCaseObject/foo/Foo.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleCaseObject/foo/Foo.class */
 package foo {
   case object Foo() extends _root_.scala.Product { this: foo.Foo.type =>
     override def hashCode(): Int = 1045991777
@@ -15,5 +13,4 @@ package foo {
           case _ => throw new IndexOutOfBoundsException(n.toString())
         }
   }
-}
---------------------------------------------------------------------------------
+}

tests/pos/simpleClass-2.decompiled

@@ -1,14 +1,8 @@
-================================================================================
-out/posTestFromTasty/pos/simpleClass-2/foo/A.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleClass-2/foo/A.class */
 package foo {
   class A() extends foo.B() {}
 }
---------------------------------------------------------------------------------
-================================================================================
-out/posTestFromTasty/pos/simpleClass-2/foo/B.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleClass-2/foo/B.class */
 package foo {
   class B() {}
-}
---------------------------------------------------------------------------------
+}

tests/pos/simpleClass.decompiled

@@ -1,14 +1,8 @@
-================================================================================
-out/posTestFromTasty/pos/simpleClass/foo/A.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleClass/foo/A.class */
 package foo {
   class A() {}
 }
---------------------------------------------------------------------------------
-================================================================================
-out/posTestFromTasty/pos/simpleClass/foo/B.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleClass/foo/B.class */
 package foo {
   class B() extends foo.A() {}
-}
---------------------------------------------------------------------------------
+}

tests/pos/simpleDoWhile.decompiled

@@ -1,6 +1,4 @@
-================================================================================
-out/posTestFromTasty/pos/simpleDoWhile/Foo.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleDoWhile/Foo.class */
 class Foo() {
   def foo: Unit =
     {
@@ -11,5 +9,4 @@ class Foo() {
         }
       while (i.!=(0))
     }
-}
---------------------------------------------------------------------------------
+}

tests/pos/simpleWhile.decompiled

@@ -1,6 +1,4 @@
-================================================================================
-out/posTestFromTasty/pos/simpleWhile/Foo.class
---------------------------------------------------------------------------------
+/** Decompiled from out/posTestFromTasty/pos/simpleWhile/Foo.class */
 class Foo() {
   def foo: Unit =
     {
@@ -10,5 +8,4 @@ class Foo() {
           i = 0
         }
     }
-}
---------------------------------------------------------------------------------
+}

tests/run/puzzle.decompiled

@@ -1,6 +1,4 @@
-================================================================================
-out/runTestFromTasty/run/puzzle/Test.class
---------------------------------------------------------------------------------
+/** Decompiled from out/runTestFromTasty/run/puzzle/Test.class */
 object Test() { this: Test.type =>
   def main(args: Array[String]): Unit =
     {
@@ -11,5 +9,4 @@ object Test() { this: Test.type =>
       val y: Float = Long.long2float(z)
       ()
     }
-}
---------------------------------------------------------------------------------
+}