Scala 3 support; Scoverage v2.0.7

Author: msigmond

build.gradle

@@ -11,7 +11,7 @@ repositories {
 group 'org.scoverage'
 description = 'gradle-scoverage is a Gradle plugin for calculating code coverage using Scoverage'
 if (project.version == 'unspecified') {
-    version = '7.0.0-SNAPSHOT'
+    version = '8.0.0-SNAPSHOT'
 }
 ext {
     website = 'http://scoverage.org'
@@ -46,7 +46,8 @@ targetCompatibility = '1.8'
 
 
 dependencies {
-    compileOnly "org.scoverage:scalac-scoverage-plugin_2.13:1.4.2"
+    compileOnly "org.scoverage:scalac-scoverage-plugin_2.13.8:2.0.5"
+    compileOnly "org.scoverage:scalac-scoverage-reporter_2.13:2.0.5"
     implementation group: 'commons-io', name: 'commons-io', version: '2.6'
 
     testImplementation 'junit:junit:4.12'

src/main/groovy/org/scoverage/ScalaVersion.groovy

@@ -0,0 +1,31 @@
+package org.scoverage
+
+class ScalaVersion {
+    final String primaryVersion
+    final Optional<String> secondaryVersion
+    final Integer majorVersion
+    final String scalacScoverageVersion
+    final String scalacScoveragePluginVersion
+    final String scalacScoverageRuntimeVersion
+
+    ScalaVersion(primaryVersion) {
+        this(primaryVersion, Optional.empty())
+    }
+
+    ScalaVersion(String primaryVersion, Optional<String> secondaryVersion) {
+        this.primaryVersion = primaryVersion
+        this.secondaryVersion = secondaryVersion
+
+        this.majorVersion = primaryVersion.substring(0, primaryVersion.indexOf('.')).toInteger()
+        this.scalacScoverageVersion = this.majorVersion < 3
+                ? primaryVersion.substring(0, primaryVersion.lastIndexOf('.'))
+                : this.majorVersion.toString()
+        this.scalacScoveragePluginVersion = secondaryVersion.orElse(primaryVersion)
+        this.scalacScoverageRuntimeVersion = scalacScoveragePluginVersion.substring(0, scalacScoveragePluginVersion.lastIndexOf('.'))
+    }
+
+    @Override
+    String toString() {
+        return majorVersion < 3 ? primaryVersion : "$primaryVersion (${secondaryVersion.get()})"
+    }
+}

src/main/groovy/org/scoverage/ScoverageAggregate.groovy

@@ -10,7 +10,7 @@ import org.gradle.api.tasks.Nested
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.TaskAction
-import scoverage.report.CoverageAggregator
+import scoverage.reporter.CoverageAggregator
 
 import static org.gradle.api.tasks.PathSensitivity.RELATIVE
 
@@ -57,7 +57,8 @@ class ScoverageAggregate extends DefaultTask {
 
             def dirs = []
             dirs.addAll(dirsToAggregateFrom.get())
-            def coverage = CoverageAggregator.aggregate(dirs.unique() as File[])
+            def sourceRoot = getProject().getRootDir()
+            def coverage = CoverageAggregator.aggregate(dirs.unique() as File[], sourceRoot)
 
             if (coverage.nonEmpty()) {
                 new ScoverageWriter(project.logger).write(

src/main/groovy/org/scoverage/ScoverageExtension.groovy

@@ -55,7 +55,7 @@ class ScoverageExtension {
         project.plugins.apply(ScalaPlugin.class)
 
         scoverageVersion = project.objects.property(String)
-        scoverageVersion.set('1.4.11')
+        scoverageVersion.set('2.0.7')
 
         scoverageScalaVersion = project.objects.property(String)
 

src/main/groovy/org/scoverage/ScoveragePlugin.groovy

@@ -51,9 +51,12 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             project.logger.info("Project ${project.name} already has the scoverage plugin")
             return
         }
-        project.logger.info("Applying scoverage plugin to $project.name")
 
+        project.logger.info("Applying scoverage plugin to $project.name")
         def extension = project.extensions.create('scoverage', ScoverageExtension, project)
+
+        def scalaVersion = resolveScalaVersions(project)
+
         if (!project.configurations.asMap[CONFIGURATION_NAME]) {
             project.configurations.create(CONFIGURATION_NAME) {
                 visible = false
@@ -62,23 +65,27 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             }
 
             project.afterEvaluate {
-                def scalaFullVersion = resolveScalaVersion(project)
-                def scalaBinaryVersion = scalaFullVersion.substring(0, scalaFullVersion.lastIndexOf('.'))
                 def scoverageVersion = project.extensions.scoverage.scoverageVersion.get()
+                project.logger.info("Using scoverage scalac plugin $scoverageVersion for scala $scalaVersion")
 
-                project.logger.info("Using scoverage scalac plugin $scoverageVersion for scala $scalaFullVersion")
+                def scalacScoverageVersion = scalaVersion.scalacScoverageVersion
+                def scalacScoveragePluginVersion = scalaVersion.scalacScoveragePluginVersion
+                def scalacScoverageRuntimeVersion = scalaVersion.scalacScoverageRuntimeVersion
 
                 project.dependencies {
-                    scoverage("org.scoverage:scalac-scoverage-plugin_$scalaFullVersion:$scoverageVersion")
-                    scoverage("org.scoverage:scalac-scoverage-runtime_$scalaBinaryVersion:$scoverageVersion")
+                    scoverage("org.scoverage:scalac-scoverage-domain_$scalacScoverageVersion:$scoverageVersion")
+                    scoverage("org.scoverage:scalac-scoverage-reporter_$scalacScoverageVersion:$scoverageVersion")
+                    scoverage("org.scoverage:scalac-scoverage-serializer_$scalacScoverageVersion:$scoverageVersion")
+                    scoverage("org.scoverage:scalac-scoverage-runtime_$scalacScoverageRuntimeVersion:$scoverageVersion")
+                    scoverage("org.scoverage:scalac-scoverage-plugin_$scalacScoveragePluginVersion:$scoverageVersion")
                 }
             }
         }
 
-        createTasks(project, extension)
+        createTasks(project, extension, scalaVersion)
     }
 
-    private void createTasks(Project project, ScoverageExtension extension) {
+    private void createTasks(Project project, ScoverageExtension extension, ScalaVersion scalaVersion) {
 
         ScoverageRunner scoverageRunner = new ScoverageRunner(project.configurations.scoverage)
 
@@ -162,32 +169,43 @@ class ScoveragePlugin implements Plugin<PluginAware> {
                 if (existingParameters) {
                     parameters.addAll(existingParameters)
                 }
-                parameters.add("-P:scoverage:dataDir:${extension.dataDir.get().absolutePath}".toString())
-                if (extension.excludedPackages.get()) {
-                    def packages = extension.excludedPackages.get().join(';')
-                    parameters.add("-P:scoverage:excludedPackages:$packages".toString())
-                }
-                if (extension.excludedFiles.get()) {
-                    def packages = extension.excludedFiles.get().join(';')
-                    parameters.add("-P:scoverage:excludedFiles:$packages".toString())
-                }
-                if (extension.highlighting.get()) {
-                    parameters.add('-Yrangepos')
-                }
-                scalaCompileOptions.additionalParameters = parameters
-                // the compile task creates a store of measured statements
-                outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage'))
-
-                dependsOn project.configurations[CONFIGURATION_NAME]
-                doFirst {
-                    /*
-                        It is crucial that this would run in `doFirst`, as this resolves the (dependencies of the)
-                        configuration, which we do not want to do at configuration time (but only at execution time).
-                     */
-                    def pluginFile = project.configurations[CONFIGURATION_NAME].find {
-                        it.name.startsWith("scalac-scoverage-plugin")
+
+                if (scalaVersion.majorVersion < 3) {
+                    parameters.add("-P:scoverage:dataDir:${extension.dataDir.get().absolutePath}".toString())
+                    parameters.add("-P:scoverage:sourceRoot:${extension.project.getRootDir().absolutePath}".toString())
+                    if (extension.excludedPackages.get()) {
+                        def packages = extension.excludedPackages.get().join(';')
+                        parameters.add("-P:scoverage:excludedPackages:$packages".toString())
+                    }
+                    if (extension.excludedFiles.get()) {
+                        def packages = extension.excludedFiles.get().join(';')
+                        parameters.add("-P:scoverage:excludedFiles:$packages".toString())
+                    }
+                    if (extension.highlighting.get()) {
+                        parameters.add('-Yrangepos')
+                    }
+                    scalaCompileOptions.additionalParameters = parameters
+                    // the compile task creates a store of measured statements
+                    outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage'))
+
+                    dependsOn project.configurations[CONFIGURATION_NAME]
+                    doFirst {
+                        /*
+                            It is crucial that this would run in `doFirst`, as this resolves the (dependencies of the)
+                            configuration, which we do not want to do at configuration time (but only at execution time).
+                         */
+                        def pluginFiles = project.configurations[CONFIGURATION_NAME].findAll {
+                            it.name.startsWith("scalac-scoverage-plugin") ||
+                            it.name.startsWith("scalac-scoverage-domain") ||
+                            it.name.startsWith("scalac-scoverage-serializer")
+                        }.collect {
+                            it.absolutePath
+                        }
+                        scalaCompileOptions.additionalParameters.add('-Xplugin:' + pluginFiles.join(":"))
                     }
-                    scalaCompileOptions.additionalParameters.add('-Xplugin:' + pluginFile.absolutePath)
+                } else {
+                    parameters.add("-coverage-out:${extension.dataDir.get().absolutePath}".toString())
+                    scalaCompileOptions.additionalParameters = parameters
                 }
             }
 
@@ -364,27 +382,41 @@ class ScoveragePlugin implements Plugin<PluginAware> {
         }
     }
 
-    private String resolveScalaVersion(Project project) {
-
+    private ScalaVersion resolveScalaVersions(Project project) {
         def scalaVersionProperty = project.extensions.scoverage.scoverageScalaVersion
         if (scalaVersionProperty.isPresent()) {
             def configuredScalaVersion = scalaVersionProperty.get()
             project.logger.info("Using configured Scala version: $configuredScalaVersion")
-            return configuredScalaVersion
+            return new ScalaVersion(configuredScalaVersion)
         } else {
             project.logger.info("No Scala version configured. Detecting scala library...")
             def components = project.configurations.compileClasspath.incoming.resolutionResult.getAllComponents()
+
+            def scala3Library = components.find {
+                it.moduleVersion.group == "org.scala-lang" && it.moduleVersion.name == "scala3-library_3"
+            }
             def scalaLibrary = components.find {
                 it.moduleVersion.group == "org.scala-lang" && it.moduleVersion.name == "scala-library"
             }
+
+            // Scala 3
+            if (scala3Library != null) {
+                def scala3Version = scala3Library.moduleVersion.version
+                def scala2Version = scalaLibrary.moduleVersion.version
+                project.logger.info("Detected scala 3 library in compilation classpath. Scala 3 version: $scala3Version; using Scala 2 library: $scala2Version")
+                return new ScalaVersion(scala3Version, Optional.of(scala2Version))
+            }
+
+            // Scala 2
             if (scalaLibrary != null) {
-                def scalaVersion = scalaLibrary.moduleVersion.version
-                project.logger.info("Detected scala library in compilation classpath. Scala version: $scalaVersion")
-                return scalaVersion
-            } else {
-                project.logger.info("No scala library detected. Using default Scala version: $DEFAULT_SCALA_VERSION")
-                return DEFAULT_SCALA_VERSION
+                def scala2Version = scalaLibrary.moduleVersion.version
+                project.logger.info("Detected scala library in compilation classpath. Scala version: $scala2Version")
+                return new ScalaVersion(scala2Version)
             }
+
+            // No Scala library was found, using default Scala version
+            project.logger.info("No scala library detected. Using default Scala version: $DEFAULT_SCALA_VERSION")
+            return new ScalaVersion(DEFAULT_SCALA_VERSION)
         }
     }
 

src/main/groovy/org/scoverage/ScoverageReport.groovy

@@ -11,7 +11,7 @@ import org.gradle.api.tasks.Nested
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.TaskAction
-import scoverage.report.CoverageAggregator
+import scoverage.reporter.CoverageAggregator
 
 import static org.gradle.api.tasks.PathSensitivity.RELATIVE
 
@@ -50,7 +50,8 @@ class ScoverageReport extends DefaultTask {
             reportDir.get().delete()
             reportDir.get().mkdirs()
 
-            def coverage = CoverageAggregator.aggregate([dataDir.get()] as File[])
+            def sourceRoot = getProject().getRootDir()
+            def coverage = CoverageAggregator.aggregate([dataDir.get()] as File[], sourceRoot)
 
             if (coverage.isEmpty()) {
                 project.logger.info("[scoverage] Could not find coverage file, skipping...")

src/main/groovy/org/scoverage/ScoverageWriter.java

@@ -5,11 +5,11 @@
 import scala.Some;
 import scala.collection.immutable.Seq;
 import scala.collection.mutable.Buffer;
-import scoverage.Constants;
-import scoverage.Coverage;
-import scoverage.report.CoberturaXmlWriter;
-import scoverage.report.ScoverageHtmlWriter;
-import scoverage.report.ScoverageXmlWriter;
+import scoverage.domain.Constants;
+import scoverage.domain.Coverage;
+import scoverage.reporter.CoberturaXmlWriter;
+import scoverage.reporter.ScoverageHtmlWriter;
+import scoverage.reporter.ScoverageXmlWriter;
 import scala.collection.JavaConverters;
 
 import java.io.File;
@@ -65,11 +65,17 @@ public void write(Set<File> sourceDirs,
         if (coverageOutputCobertura) {
             Constructor<CoberturaXmlWriter> cst;
             try {
-                cst = CoberturaXmlWriter.class.getConstructor(Class.forName("scala.collection.immutable.Seq"), File.class);
+                cst = CoberturaXmlWriter.class.getConstructor(
+                        Class.forName("scala.collection.immutable.Seq"),
+                        File.class,
+                        Class.forName("scala.Option"));
             } catch (NoSuchMethodException | ClassNotFoundException e) {
-                cst = CoberturaXmlWriter.class.getConstructor(Class.forName("scala.collection.Seq"), File.class);
+                cst = CoberturaXmlWriter.class.getConstructor(
+                        Class.forName("scala.collection.Seq"),
+                        File.class,
+                        Class.forName("scala.Option"));
             }
-            CoberturaXmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir);
+            CoberturaXmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir, new Some<>(sourceEncoding));
             writer.write(coverage);
             logger.info("[scoverage] Written Cobertura XML report to " +
                 reportDir.getAbsolutePath() +
@@ -80,11 +86,19 @@ public void write(Set<File> sourceDirs,
         if (coverageOutputXML) {
             Constructor<ScoverageXmlWriter> cst;
             try {
-                cst = ScoverageXmlWriter.class.getConstructor(Class.forName("scala.collection.immutable.Seq"), File.class, boolean.class);
+                cst = ScoverageXmlWriter.class.getConstructor(
+                        Class.forName("scala.collection.immutable.Seq"),
+                        File.class,
+                        boolean.class,
+                        Class.forName("scala.Option"));
             } catch (NoSuchMethodException | ClassNotFoundException e) {
-                cst = ScoverageXmlWriter.class.getConstructor(Class.forName("scala.collection.Seq"), File.class, boolean.class);
+                cst = ScoverageXmlWriter.class.getConstructor(
+                        Class.forName("scala.collection.Seq"),
+                        File.class,
+                        boolean.class,
+                        Class.forName("scala.Option"));
             }
-            ScoverageXmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir, false);
+            ScoverageXmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir, false, new Some<>(sourceEncoding));
             writer.write(coverage);
             logger.info("[scoverage] Written XML report to " +
                 reportDir.getAbsolutePath() +