Move coverage phase to before FirstTransform and handle more trees

Author: TheElectronWill

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -46,7 +46,6 @@ class Compiler {
     List(new sjs.PrepJSInterop) ::  // Additional checks and transformations for Scala.js (Scala.js only)
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
     List(new SetRootTree) ::        // Set the `rootTreeOrProvider` on class symbols
-    List(new CoverageTransformMacro) :: // Perform instrumentation for coverage transform (if -coverage is present)
     Nil
 
   /** Phases dealing with TASTY tree pickling and unpickling */
@@ -60,6 +59,7 @@ class Compiler {
 
   /** Phases dealing with the transformation from pickled trees to backend trees */
   protected def transformPhases: List[List[Phase]] =
+    List(new InstrumentCoverage) ::  // Perform instrumentation for code coverage (if -coverage setting is set)
     List(new FirstTransform,         // Some transformations to put trees into a canonical form
          new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
          new ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes

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

@@ -3,13 +3,12 @@ package coverage
 
 import scala.collection.mutable
 
-class Coverage {
+class Coverage:
   private val statementsById = mutable.Map[Int, Statement]()
 
-  def statements = statementsById.values
+  def statements: Iterable[Statement] = statementsById.values
 
-  def addStatement(stmt: Statement): Unit = statementsById.put(stmt.id, stmt)
-}
+  def addStatement(stmt: Statement): Unit = statementsById(stmt.id) = stmt
 
 case class Statement(
     source: String,
@@ -24,7 +23,9 @@ case class Statement(
     branch: Boolean,
     var count: Int = 0,
     ignored: Boolean = false
-) {
-  def invoked(): Unit = count = count + 1
-  def isInvoked = count > 0
-}
+):
+  def invoked(): Unit =
+    count += 1
+
+  def isInvoked: Boolean =
+    count > 0

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

@@ -20,8 +20,8 @@ final case class Location(
     sourcePath: String
 )
 
-object Location {
-  def apply(tree: Tree)(using ctx: Context): Location = {
+object Location:
+  def apply(tree: Tree)(using ctx: Context): Location =
 
     val packageName = ctx.owner.denot.enclosingPackageClass.name.toSimpleName.toString()
     val className = ctx.owner.denot.enclosingClass.name.toSimpleName.toString()
@@ -34,5 +34,3 @@ object Location {
       ctx.owner.denot.enclosingMethod.name.toSimpleName.toString(),
       ctx.source.file.absolute.toString()
     )
-  }
-}

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

@@ -5,31 +5,34 @@ import java.io._
 
 import scala.io.Source
 
-object Serializer {
+/**
+ * Serializes scoverage data.
+ * @see https://github.com/scoverage/scalac-scoverage-plugin/blob/main/scalac-scoverage-plugin/src/main/scala/scoverage/Serializer.scala
+ */
+object Serializer:
 
-  val coverageFileName = "scoverage.coverage"
-  val coverageDataFormatVersion = "3.0"
-  // Write out coverage data to the given data directory, using the default coverage filename
+  private val CoverageFileName = "scoverage.coverage"
+  private val CoverageDataFormatVersion = "3.0"
+
+  /** 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, coverageFile(dataDir), new File(sourceRoot))
 
-  // Write out coverage data to given file.
-  def serialize(coverage: Coverage, file: File, sourceRoot: File): Unit = {
-    val writer = new BufferedWriter(new FileWriter(file))
+  /** Write out coverage data to given file. */
+  def serialize(coverage: Coverage, file: File, sourceRoot: File): Unit =
+    val writer = BufferedWriter(FileWriter(file))
     serialize(coverage, writer, sourceRoot)
     writer.close()
-  }
 
-  def serialize(coverage: Coverage, writer: Writer, sourceRoot: File): Unit = {
+  def serialize(coverage: Coverage, writer: Writer, sourceRoot: File): Unit =
 
-    def getRelativePath(filePath: String): String = {
+    def getRelativePath(filePath: String): String =
       val base = sourceRoot.getCanonicalFile().toPath()
-      val relPath = base.relativize(new File(filePath).getCanonicalFile().toPath())
+      val relPath = base.relativize(File(filePath).getCanonicalFile().toPath())
       relPath.toString
-    }
 
-    def writeHeader(writer: Writer): Unit = {
-      writer.write(s"""# Coverage data, format version: $coverageDataFormatVersion
+    def writeHeader(writer: Writer): Unit =
+      writer.write(s"""# Coverage data, format version: $CoverageDataFormatVersion
                       |# Statement data:
                       |# - id
                       |# - source path
@@ -50,8 +53,8 @@ object Serializer {
                       |# '\f' sign
                       |# ------------------------------------------
                       |""".stripMargin)
-    }
-    def writeStatement(stmt: Statement, writer: Writer): Unit = {
+
+    def writeStatement(stmt: Statement, writer: Writer): Unit =
       writer.write(s"""${stmt.id}
                       |${getRelativePath(stmt.location.sourcePath)}
                       |${stmt.location.packageName}
@@ -70,14 +73,11 @@ object Serializer {
                       |${stmt.desc}
                       |\f
                       |""".stripMargin)
-    }
 
     writeHeader(writer)
-    coverage.statements.toVector
+    coverage.statements.toSeq
       .sortBy(_.id)
       .foreach(stmt => writeStatement(stmt, writer))
-  }
 
   def coverageFile(dataDir: File): File = coverageFile(dataDir.getAbsolutePath)
-  def coverageFile(dataDir: String): File = new File(dataDir, coverageFileName)
-}
+  def coverageFile(dataDir: String): File = File(dataDir, CoverageFileName)