Add tests and fix implementation

Author: lolgab

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

@@ -8,16 +8,16 @@ import java.nio.file.Path
 class Coverage:
   private val statementsById = new mutable.LongMap[Statement](256)
 
-  private var statementId: Int = 0
-
-  def nextStatementId(): Int =
-    statementId += 1
-    statementId - 1
+  private var _nextStatementId: Int = 1
 
+  def nextStatementId(): Int = _nextStatementId
+  def setNextStatementId(id: Int): Unit = _nextStatementId = id
 
   def statements: Iterable[Statement] = statementsById.values
 
-  def addStatement(stmt: Statement): Unit = statementsById(stmt.id) = stmt
+  def addStatement(stmt: Statement): Unit =
+    if stmt.id >= _nextStatementId then _nextStatementId = stmt.id + 1
+    statementsById(stmt.id) = stmt
 
   def removeStatementsFromFile(sourcePath: Path | Null) =
     val removedIds = statements.filter(_.location.sourcePath == sourcePath).map(_.id.toLong)

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

@@ -16,7 +16,7 @@ object Serializer:
   private val CoverageFileName = "scoverage.coverage"
   private val CoverageDataFormatVersion = "3.0"
 
-  def coverageFilePath(dataDir: String) =
+  def coverageFilePath(dataDir: String): Path =
     Paths.get(dataDir, CoverageFileName).toAbsolutePath
 
   /** Write out coverage data to the given data directory, using the default coverage filename */
@@ -90,12 +90,12 @@ object Serializer:
       .sortBy(_.id)
       .foreach(stmt => writeStatement(stmt, writer))
 
-  def deserialize(file: Path): Coverage =
+  def deserialize(file: Path, sourceRoot: String): Coverage =
     val source = Source.fromFile(file.toFile(), UTF_8.name())
-    try deserialize(source.getLines())
+    try deserialize(source.getLines(), Paths.get(sourceRoot).toAbsolutePath)
     finally source.close()
 
-  def deserialize(lines: Iterator[String]): Coverage =
+  def deserialize(lines: Iterator[String], sourceRoot: Path): Coverage =
     def toStatement(lines: Iterator[String]): Statement =
       val id: Int = lines.next().toInt
       val sourcePath = lines.next()
@@ -110,7 +110,7 @@ object Serializer:
         fullClassName,
         classType,
         method,
-        Paths.get(sourcePath)
+        sourceRoot.resolve(sourcePath)
       )
       val start: Int = lines.next().toInt
       val end: Int = lines.next().toInt

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

@@ -61,7 +61,7 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
     val coverageFilePath = Serializer.coverageFilePath(outputPath)
     val previousCoverage =
       if Files.exists(coverageFilePath) then
-        Serializer.deserialize(coverageFilePath)
+        Serializer.deserialize(coverageFilePath, ctx.settings.sourceroot.value)
       else Coverage()
 
     // Initialise a coverage object if it does not exist yet
@@ -72,6 +72,8 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
     coverageExcludeFilePatterns = ctx.settings.coverageExcludeFiles.value.map(_.r.pattern)
 
     ctx.base.coverage.nn.removeStatementsFromFile(ctx.compilationUnit.source.file.absolute.jpath)
+    ctx.base.coverage.nn.setNextStatementId(previousCoverage.nextStatementId())
+
     super.run
 
     val mergedCoverage = Coverage()

compiler/test/dotty/tools/dotc/coverage/CoverageTests.scala

@@ -18,6 +18,7 @@ import scala.language.unsafeNulls
 import scala.collection.mutable.Buffer
 import dotty.tools.dotc.util.DiffUtil
 
+import java.nio.charset.StandardCharsets
 import java.util.stream.Collectors
 
 @Category(Array(classOf[BootstrappedOnlyTests]))
@@ -127,6 +128,71 @@ class CoverageTests:
     )
   }
 
+  @Test
+  def checkIncrementalCoverage(): Unit =
+    val target = Files.createTempDirectory("coverage")
+    val sourceRoot = target.resolve("src")
+    Files.createDirectory(sourceRoot)
+    val sourceFile1 = sourceRoot.resolve("file1.scala")
+    Files.write(sourceFile1, "def file1() = 1".getBytes(StandardCharsets.UTF_8))
+
+    val coverageOut = target.resolve("coverage-out")
+    Files.createDirectory(coverageOut)
+    val options = defaultOptions.and("-Ycheck:instrumentCoverage", "-coverage-out", coverageOut.toString, "-sourceroot", sourceRoot.toString)
+    compileFile(sourceFile1.toString, options).checkCompile()
+
+    val scoverageFile = coverageOut.resolve("scoverage.coverage")
+    assert(Files.exists(scoverageFile), s"Expected scoverage file to exist at $scoverageFile")
+
+    locally {
+      val coverage = Serializer.deserialize(scoverageFile, sourceRoot.toString())
+      val filesWithCoverage = coverage.statements.map(_.location.sourcePath.getFileName.toString).toSet
+      assertEquals(Set("file1.scala"), filesWithCoverage)
+    }
+
+    val sourceFile2 = sourceRoot.resolve("file2.scala")
+    Files.write(sourceFile2, "def file2() = 2".getBytes(StandardCharsets.UTF_8))
+
+    compileFile(sourceFile2.toString, options).checkCompile()
+    locally {
+      val coverage = Serializer.deserialize(scoverageFile, sourceRoot.toString())
+      val filesWithCoverage = coverage.statements.map(_.location.sourcePath.getFileName.toString).toSet
+      assertEquals(Set("file1.scala", "file2.scala"), filesWithCoverage)
+    }
+
+  @Test
+  def `deleted source files should not be kept in incremental coverage`(): Unit =
+    val target = Files.createTempDirectory("coverage")
+    val sourceRoot = target.resolve("src")
+    Files.createDirectory(sourceRoot)
+    val sourceFile1 = sourceRoot.resolve("file1.scala")
+    Files.write(sourceFile1, "def file1() = 1".getBytes(StandardCharsets.UTF_8))
+
+    val coverageOut = target.resolve("coverage-out")
+    Files.createDirectory(coverageOut)
+    val options = defaultOptions.and("-Ycheck:instrumentCoverage", "-coverage-out", coverageOut.toString, "-sourceroot", sourceRoot.toString)
+    compileFile(sourceFile1.toString, options).checkCompile()
+
+    val scoverageFile = coverageOut.resolve("scoverage.coverage")
+    assert(Files.exists(scoverageFile), s"Expected scoverage file to exist at $scoverageFile")
+
+    locally {
+      val coverage = Serializer.deserialize(scoverageFile, sourceRoot.toString())
+      val filesWithCoverage = coverage.statements.map(_.location.sourcePath.getFileName.toString).toSet
+      assertEquals(Set("file1.scala"), filesWithCoverage)
+    }
+
+    val sourceFile2 = sourceRoot.resolve("file2.scala")
+    Files.write(sourceFile2, "def file2() = 2".getBytes(StandardCharsets.UTF_8))
+
+    Files.delete(sourceFile1)
+
+    compileFile(sourceFile2.toString, options).checkCompile()
+    locally {
+      val coverage = Serializer.deserialize(scoverageFile, sourceRoot.toString())
+      val filesWithCoverage = coverage.statements.map(_.location.sourcePath.getFileName.toString).toSet
+      assertEquals(Set("file2.scala"), filesWithCoverage)
+    }
 
 object CoverageTests extends ParallelTesting:
   import scala.concurrent.duration.*