Compiler Plugin

/**
 * Main Scoverage compiler plugin class
 * @param global The Scala compiler's Global object
 */
class ScoveragePlugin(val global: Global) extends Plugin {
  /** Plugin name identifier */
  val name: String
  
  /** Human-readable plugin description */
  val description: String
  
  /** List of plugin components that perform the instrumentation */
  val components: List[PluginComponent]
  
  /** Initialize plugin with command-line options */
  def init(opts: List[String], error: String => Unit): Boolean
  
  /** Help text for plugin options */
  val optionsHelp: Option[String]
}

/**
 * Configuration options for the Scoverage plugin
 * @param excludedPackages Regex patterns for packages to exclude from instrumentation
 * @param excludedFiles Regex patterns for files to exclude from instrumentation
 * @param excludedSymbols Regex patterns for symbols to exclude from instrumentation
 * @param dataDir Directory where coverage data files are written
 * @param reportTestName Whether to include test names in coverage reports
 * @param sourceRoot Root directory for source files
 */
case class ScoverageOptions(
  excludedPackages: Seq[String],
  excludedFiles: Seq[String],
  excludedSymbols: Seq[String],
  dataDir: String,
  reportTestName: Boolean,
  sourceRoot: String
)

object ScoverageOptions {
  /** Create default options */
  def default(): ScoverageOptions
  
  /** Parse command-line options into ScoverageOptions */
  def parse(scalacOptions: List[String], errFn: String => Unit, base: ScoverageOptions): ScoverageOptions
  
  /** Process phase options for before/after phase configuration */
  def processPhaseOptions(opts: List[String]): (Option[String], Option[String])
  
  /** Help text for all available options */
  val help: Option[String]
}

import scoverage.ScoverageOptions

// Create custom configuration
val options = ScoverageOptions(
  excludedPackages = Seq(".*\\.test\\..*", ".*\\.generated\\..*"),
  excludedFiles = Seq(".*DatabaseMigrations.*"),
  excludedSymbols = Seq(".*Logger.*"),
  dataDir = "target/scoverage-data",  
  reportTestName = true,
  sourceRoot = "src/main/scala"
)

// Parse from compiler options
val opts = List(
  "-P:scoverage:dataDir:target/scoverage-data",
  "-P:scoverage:excludedPackages:.*\\.test\\..*",
  "-P:scoverage:reportTestName:true"
)
val parsed = ScoverageOptions.parse(opts, println, ScoverageOptions.default())

/**
 * Base trait for filtering what code should be included in coverage
 */
trait CoverageFilter {
  /** Check if a class should be included in coverage */
  def isClassIncluded(className: String): Boolean
  
  /** Check if a source file should be included in coverage */
  def isFileIncluded(file: SourceFile): Boolean
  
  /** Check if a specific line position should be included */
  def isLineIncluded(position: Position): Boolean
  
  /** Check if a symbol should be included in coverage */
  def isSymbolIncluded(symbolName: String): Boolean
  
  /** Get line number ranges that are excluded from coverage */
  def getExcludedLineNumbers(sourceFile: SourceFile): List[Range]
}

/**
 * Filter that includes all code (no exclusions)
 */
object AllCoverageFilter extends CoverageFilter

/**
 * Regex-based filter for excluding code from coverage
 * @param excludedPackages Regex patterns for package exclusion
 * @param excludedFiles Regex patterns for file exclusion  
 * @param excludedSymbols Regex patterns for symbol exclusion
 * @param reporter Compiler reporter for error handling
 */
class RegexCoverageFilter(
  excludedPackages: Seq[String],
  excludedFiles: Seq[String],
  excludedSymbols: Seq[String],
  reporter: Reporter
) extends CoverageFilter

import scoverage.{RegexCoverageFilter, AllCoverageFilter}

// Create filter with exclusions
val filter = new RegexCoverageFilter(
  excludedPackages = Seq(".*\\.test\\..*", ".*\\.generated\\..*"),
  excludedFiles = Seq(".*Migration.*\\.scala"),
  excludedSymbols = Seq(".*Logger.*", ".*Debug.*"),
  reporter = global.reporter
)

// Check if class should be covered
val shouldCover = filter.isClassIncluded("com.example.service.UserService")

// Use no-exclusion filter
val allFilter = AllCoverageFilter

/**
 * Compiler plugin component that performs code instrumentation
 * @param global The Scala compiler's Global object  
 * @param extraAfterPhase Optional phase to run after
 * @param extraBeforePhase Optional phase to run before
 */
class ScoverageInstrumentationComponent(
  val global: Global,
  extraAfterPhase: Option[String],
  extraBeforePhase: Option[String]
) extends PluginComponent with TypingTransformers with Transform {

  /** Phase name for the instrumentation */
  val phaseName: String
  
  /** Phases this component must run after */
  val runsAfter: List[String]
  
  /** Phases this component must run before */
  val runsBefore: List[String]
  
  /** Configure options for this component */
  def setOptions(options: ScoverageOptions): Unit
  
  /** Create new phase instance */
  def newPhase(prev: scala.tools.nsc.Phase): Phase
}

/**
 * Utilities for extracting location information from compiler trees
 */
object Location {
  /**
   * Create location extractor function for a specific compiler instance
   * @param global The compiler's Global object
   * @returns Function to extract Location from compiler Tree nodes
   */
  def fromGlobal(global: Global): global.Tree => Option[scoverage.domain.Location]
}

// project/plugins.sbt
addSbtPlugin("org.scoverage" % "sbt-scoverage" % "2.3.0")

// build.sbt  
scoverageExcludedPackages := ".*\\.test\\..*;.*\\.generated\\..*"
scoverageExcludedFiles := ".*DatabaseMigrations.*"
scoverageMinimumCoverage := 80.0
scoverageFailOnMinimumCoverage := true

// Add to scalacOptions
scalacOptions ++= Seq(
  "-Xplugin:/path/to/scalac-scoverage-plugin.jar",
  "-P:scoverage:dataDir:target/scoverage-data",
  "-P:scoverage:excludedPackages:.*\\.test\\..*;.*\\.generated\\..*",
  "-P:scoverage:reportTestName:true",
  "-P:scoverage:sourceRoot:src/main/scala"
)

// $COVERAGE-OFF$
def debugOnlyMethod(): Unit = {
  println("This won't be covered")
}
// $COVERAGE-ON$

def normalMethod(): Unit = {
  // This will be covered normally
  println("Normal method")
}