Make coverage support incremental compilation

Author: lolgab

compiler/src/dotty/tools/dotc/coverage/Serializer.scala

@@ -1,22 +1,27 @@
 package dotty.tools.dotc
 package coverage
 
+import java.nio.charset.StandardCharsets.UTF_8
 import java.nio.file.{Path, Paths, Files}
 import java.io.Writer
 import scala.collection.mutable.StringBuilder
+import scala.io.Source
 
 /**
  * Serializes scoverage data.
- * @see https://github.com/scoverage/scalac-scoverage-plugin/blob/main/scalac-scoverage-plugin/src/main/scala/scoverage/Serializer.scala
+ * @see https://github.com/scoverage/scalac-scoverage-plugin/blob/main/serializer/src/main/scala/scoverage/serialize/Serializer.scala
  */
 object Serializer:
 
   private val CoverageFileName = "scoverage.coverage"
   private val CoverageDataFormatVersion = "3.0"
 
+  def coverageFilePath(dataDir: String) =
+    Paths.get(dataDir, CoverageFileName).toAbsolutePath
+
   /** Write out coverage data to the given data directory, using the default coverage filename */
   def serialize(coverage: Coverage, dataDir: String, sourceRoot: String): Unit =
-    serialize(coverage, Paths.get(dataDir, CoverageFileName).toAbsolutePath, Paths.get(sourceRoot).toAbsolutePath)
+    serialize(coverage, coverageFilePath(dataDir), Paths.get(sourceRoot).toAbsolutePath)
 
   /** Write out coverage data to a file. */
   def serialize(coverage: Coverage, file: Path, sourceRoot: Path): Unit =
@@ -85,6 +90,64 @@ object Serializer:
       .sortBy(_.id)
       .foreach(stmt => writeStatement(stmt, writer))
 
+  def deserialize(file: Path): Coverage =
+    val source = Source.fromFile(file.toFile(), UTF_8.name())
+    try deserialize(source.getLines())
+    finally source.close()
+
+  def deserialize(lines: Iterator[String]): Coverage =
+    def toStatement(lines: Iterator[String]): Statement =
+      val id: Int = lines.next().toInt
+      val sourcePath = lines.next()
+      val packageName = lines.next()
+      val className = lines.next()
+      val classType = lines.next()
+      val fullClassName = lines.next()
+      val method = lines.next()
+      val loc = Location(
+        packageName,
+        className,
+        fullClassName,
+        classType,
+        method,
+        Paths.get(sourcePath)
+      )
+      val start: Int = lines.next().toInt
+      val end: Int = lines.next().toInt
+      val lineNo: Int = lines.next().toInt
+      val symbolName: String = lines.next()
+      val treeName: String = lines.next()
+      val branch: Boolean = lines.next().toBoolean
+      val count: Int = lines.next().toInt
+      val ignored: Boolean = lines.next().toBoolean
+      val desc = lines.toList.mkString("\n")
+      Statement(
+        loc,
+        id,
+        start,
+        end,
+        lineNo,
+        desc,
+        symbolName,
+        treeName,
+        branch,
+        ignored
+      )
+
+    val headerFirstLine = lines.next()
+    require(
+      headerFirstLine == s"# Coverage data, format version: $CoverageDataFormatVersion",
+      "Wrong file format"
+    )
+
+    val linesWithoutHeader = lines.dropWhile(_.startsWith("#"))
+    val coverage = Coverage()
+    while !linesWithoutHeader.isEmpty do
+      val oneStatementLines = linesWithoutHeader.takeWhile(_ != "\f")
+      coverage.addStatement(toStatement(oneStatementLines))
+    end while
+    coverage
+
   /** Makes a String suitable for output in the coverage statement data as a single line.
    * Escaped characters: '\\' (backslash), '\n', '\r', '\f'
    */

compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala

@@ -2,6 +2,7 @@ package dotty.tools.dotc
 package transform
 
 import java.io.File
+import java.nio.file.Files
 
 import ast.tpd.*
 import collection.mutable
@@ -41,6 +42,7 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
 
   private var coverageExcludeClasslikePatterns: List[Pattern] = Nil
   private var coverageExcludeFilePatterns: List[Pattern] = Nil
+  private var lastCompiledFiles: Set[String] = Set.empty
 
   override def run(using ctx: Context): Unit =
     val outputPath = ctx.settings.coverageOutputDir.value
@@ -50,12 +52,18 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
     val newlyCreated = dataDir.mkdirs()
 
     if !newlyCreated then
-      // If the directory existed before, let's clean it up.
+      // If the directory existed before, clean measurement files.
       dataDir.listFiles
-        .filter(_.getName.startsWith("scoverage"))
+        .filter(_.getName.startsWith("scoverage.measurements."))
         .foreach(_.delete())
     end if
 
+    val coverageFilePath = Serializer.coverageFilePath(outputPath)
+    val previousCoverage =
+      if Files.exists(coverageFilePath) then
+        Serializer.deserialize(coverageFilePath)
+      else Coverage()
+
     // Initialise a coverage object if it does not exist yet
     if ctx.base.coverage == null then
       ctx.base.coverage = Coverage()
@@ -66,7 +74,19 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
     ctx.base.coverage.nn.removeStatementsFromFile(ctx.compilationUnit.source.file.absolute.jpath)
     super.run
 
-    Serializer.serialize(ctx.base.coverage.nn, outputPath, ctx.settings.sourceroot.value)
+    val mergedCoverage = Coverage()
+
+    previousCoverage.statements
+      .filterNot(stmt =>
+        val source = stmt.location.sourcePath
+        lastCompiledFiles.contains(source.toString) || !Files.exists(source)
+      )
+      .foreach { stmt =>
+        mergedCoverage.addStatement(stmt)
+      }
+    ctx.base.coverage.nn.statements.foreach(stmt => mergedCoverage.addStatement(stmt))
+
+    Serializer.serialize(mergedCoverage, outputPath, ctx.settings.sourceroot.value)
 
   private def isClassIncluded(sym: Symbol)(using Context): Boolean =
     val fqn = sym.fullName.toText(ctx.printerFn(ctx)).show
@@ -253,6 +273,7 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
         InstrumentedParts.singleExprTree(coverageCall, transformed)
 
     override def transform(tree: Tree)(using Context): Tree =
+      lastCompiledFiles += tree.sourcePos.source.file.absolute.jpath.toString
       inContext(transformCtx(tree)) { // necessary to position inlined code properly
         tree match
           // simple cases