Better handling of ctrl-c while the compiler is running

compiler/src/dotty/tools/backend/jvm/BytecodeWriters.scala

@@ -3,6 +3,8 @@ package backend
 package jvm
 
 import java.io.{ DataOutputStream, FileOutputStream, IOException, OutputStream, File => JFile }
+import java.nio.channels.ClosedByInterruptException
+import java.nio.file.Files
 import dotty.tools.io._
 import dotty.tools.dotc.report
 
@@ -112,6 +114,11 @@ trait BytecodeWriters {
       val outstream = new DataOutputStream(outfile.bufferedOutput)
 
       try outstream.write(jclassBytes, 0, jclassBytes.length)
+      catch case ex: ClosedByInterruptException =>
+        try
+          outfile.delete() // don't leave an empty or half-written classfile around after an interrupt
+        catch case _: Throwable =>
+        throw ex
       finally outstream.close()
       report.informProgress("wrote '" + label + "' to " + outfile)
     }

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -22,6 +22,7 @@ import Symbols._
 import Decorators._
 
 import java.io.DataOutputStream
+import java.nio.channels.ClosedByInterruptException
 
 import dotty.tools.tasty.{ TastyBuffer, TastyHeaderUnpickler }
 
@@ -190,6 +191,8 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using Context) extends BC
         else {
           try   { /*withCurrentUnit(item.cunit)*/(visit(item)) }
           catch {
+            case ex: InterruptedException =>
+              throw ex
             case ex: Throwable =>
               println(s"Error while emitting ${item.cunit.source.file.name}")
               throw ex
@@ -233,6 +236,11 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using Context) extends BC
               val outTastyFile = getFileForClassfile(outF, store.name, ".tasty")
               val outstream = new DataOutputStream(outTastyFile.bufferedOutput)
               try outstream.write(binary)
+              catch case ex: ClosedByInterruptException =>
+                try
+                  outTastyFile.delete() // don't leave an empty or half-written tastyfile around after an interrupt
+                catch case _: Throwable =>
+                throw ex
               finally outstream.close()
 
               val uuid = new TastyHeaderUnpickler(binary).readHeader()
@@ -424,6 +432,8 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using Context) extends BC
               addLambdaDeserialize(plainNode, serializableLambdas)
             addToQ3(item)
           } catch {
+            case ex: InterruptedException =>
+              throw ex
             case ex: Throwable =>
               println(s"Error while emitting ${item.plain.classNode.name}")
               throw ex

compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -3,6 +3,7 @@ package dotc
 package core
 
 import java.io.{IOException, File}
+import java.nio.channels.ClosedByInterruptException
 import scala.compat.Platform.currentTime
 import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import config.Config
@@ -343,6 +344,10 @@ abstract class SymbolLoader extends LazyType { self =>
       report.informTime("loaded " + description, start)
     }
     catch {
+      case ex: InterruptedException =>
+        throw ex
+      case ex: ClosedByInterruptException =>
+        throw new InterruptedException
       case ex: IOException =>
         signalError(ex)
       case NonFatal(ex: TypeError) =>