Fix incremental compilation issue with TASTY files

We cannot delegate to the default class file manager. In some
situations, when an incremental compilation fails, we need to restore
tasty files from previous compilation. These tasty files must be backed
up in a tmp directory which is different from the one of the default
class file manager.

Author: allanrenucci

sbt-dotty/src/dotty/tools/sbtplugin/DottyPlugin.scala

@@ -112,33 +112,20 @@ object DottyPlugin extends AutoPlugin {
    *  corresponding .tasty or .hasTasty file is also deleted.
    */
   def dottyPatchIncOptions(incOptions: IncOptions): IncOptions = {
-    val inheritedNewClassFileManager = ClassFileManagerUtil.getDefaultClassFileManager(incOptions)
-    val tastyFileManager = new ClassFileManager {
-      private[this] val inherited = inheritedNewClassFileManager
-
-      def delete(classes: Array[File]): Unit = {
-        val tastySuffixes = List(".tasty", ".hasTasty")
-        inherited.delete(classes flatMap { classFile =>
-          if (classFile.getPath endsWith ".class") {
-            val prefix = classFile.getAbsolutePath.stripSuffix(".class")
-            tastySuffixes.map(suffix => new File(prefix + suffix)).filter(_.exists)
-          } else Nil
-        })
-      }
+    val tastyFileManager = new TastyFileManager
 
-      def generated(classes: Array[File]): Unit = {}
-      def complete(success: Boolean): Unit = {}
-    }
+    // Once sbt/zinc#562 is fixed, can be:
+    // val newExternalHooks =
+    //   incOptions.externalHooks.withExternalClassFileManager(tastyFileManager)
     val inheritedHooks = incOptions.externalHooks
-    val externalClassFileManager: Optional[ClassFileManager] = Option(inheritedHooks.getExternalClassFileManager.orElse(null)) match {
-        case Some(prevManager) =>
-          Optional.of(WrappedClassFileManager.of(prevManager, Optional.of(tastyFileManager)))
-        case None =>
-          Optional.of(tastyFileManager)
-      }
-
-    val hooks = new DefaultExternalHooks(inheritedHooks.getExternalLookup, externalClassFileManager)
-    incOptions.withExternalHooks(hooks)
+    val external = Optional.of(tastyFileManager: ClassFileManager)
+    val prevManager = inheritedHooks.getExternalClassFileManager
+    val fileManager: Optional[ClassFileManager] =
+      if (prevManager.isPresent) Optional.of(WrappedClassFileManager.of(prevManager.get, external))
+      else external
+    val newExternalHooks = new DefaultExternalHooks(inheritedHooks.getExternalLookup, fileManager)
+
+    incOptions.withExternalHooks(newExternalHooks)
   }
 
   override val globalSettings: Seq[Def.Setting[_]] = Seq(

sbt-dotty/src/dotty/tools/sbtplugin/TastyFileManager.scala

@@ -0,0 +1,62 @@
+package dotty.tools.sbtplugin
+
+import java.io.File
+import java.nio.file.Files
+
+import sbt.io.IO
+import xsbti.compile.ClassFileManager
+
+import scala.collection.mutable
+
+
+/** A class file manger that prunes .tasty and .hasTasty as needed.
+ *
+ *  This makes sure that, when a .class file must be deleted, the
+ *  corresponding .tasty or .hasTasty file is also deleted.
+ *
+ *  This code is adapted from Zinc `TransactionalClassFileManager`.
+ *  We need to duplicate the logic since forwarding to the default class
+ *  file manager doesn't work: we need to backup tasty files in a different
+ *  temporary directory as class files.
+ */
+final class TastyFileManager extends ClassFileManager {
+  private[this] val tempDir = Files.createTempDirectory("backup").toFile
+
+  private[this] val generatedTastyFiles = new mutable.HashSet[File]
+  private[this] val movedTastyFiles = new mutable.HashMap[File, File]
+
+  override def delete(classes: Array[File]): Unit = {
+    val toBeBackedUp = tastyFiles(classes)
+      .filter(t => t.exists && !movedTastyFiles.contains(t) && !generatedTastyFiles(t))
+    for (c <- toBeBackedUp)
+      movedTastyFiles.put(c, move(c))
+    IO.deleteFilesEmptyDirs(classes)
+  }
+
+  override def generated(classes: Array[File]): Unit =
+    generatedTastyFiles ++= tastyFiles(classes)
+
+  override def complete(success: Boolean): Unit = {
+    if (!success) {
+      IO.deleteFilesEmptyDirs(generatedTastyFiles)
+      for ((orig, tmp) <- movedTastyFiles) IO.move(tmp, orig)
+    }
+    IO.delete(tempDir)
+  }
+
+  private def tastyFiles(classes: Array[File]): Array[File] = {
+    val tastySuffixes = List(".tasty", ".hasTasty")
+    classes.flatMap { classFile =>
+      if (classFile.getPath.endsWith(".class")) {
+        val prefix = classFile.getAbsolutePath.stripSuffix(".class")
+        tastySuffixes.map(suffix => new File(prefix + suffix)).filter(_.exists)
+      } else Nil
+    }
+  }
+
+  private def move(c: File): File = {
+    val target = File.createTempFile("sbt", ".tasty", tempDir)
+    IO.move(c, target)
+    target
+  }
+}