Sidestep Zinc and use the compiler interface directly

Basic benchmarking shows that we're incurring a ~49% overhead from using
Zinc instead of the Scala compiler directly. That is, we wrote a basic
worker that invokes the Scala 2 compiler programmatically via
`scala.tools.nsc.Main`, and found that it was ~49% faster
across-the-board.

This doesn't necessarily mean that we can speed up `ZincRunner` by 49%.
A lot of that time is spent in compilation phases
[added](https://github.com/scala/scala/blob/2.13.x/src/sbt-bridge/scala/tools/xsbt/CallbackGlobal.scala#L166)
by the compiler bridge (implementation of the compiler interface)
itself. There are three of these phases; they're responsible for:
1. Mapping generated `.class` files to sources
2. Analyzing depedendencies between code
3. Producing the analysis information outputted by Zinc

We rely on 2 and 3 for:
- Dependency checking
- Detecting main classes
- Test discovery

We only use 2 and 3, and although it's likely the phases could be
slimmed down to only extract the information we need, implementing them
ourselves would add a lot of complexity to `ZincRunner` and make it
less portable . There's also no guarantee
that we could do a better job.

What can be eliminated is all the overhead related to incremental
compilation. We haven't used incremental compilation for years and have
no intention of re-enabling it.

This commit isn't about ripping out Zinc entirely; we still use Zinc for
the following things:
- Classloading the compiler interface from the compiler classpath
- Implementations of various `xsbti.*` traits and interfaces

Author: jadenPete-lucid

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/AnnexAnalysis.scala

@@ -0,0 +1,92 @@
+package higherkindness.rules_scala.workers.zinc.compile
+
+import java.io.File
+import java.nio.file.Path
+import java.util
+import java.util.Optional
+import sbt.internal.inc.SourceInfos
+import scala.collection.mutable.ArrayBuffer
+import xsbti.*
+import xsbti.api.{ClassLike, DependencyContext}
+import xsbti.compile.analysis.ReadSourceInfos
+
+case class AnnexAnalysis(
+  apis: ArrayBuffer[ClassLike] = ArrayBuffer.empty,
+  mainClasses: ArrayBuffer[String] = ArrayBuffer.empty,
+  usedJars: ArrayBuffer[Path] = ArrayBuffer.empty,
+) {
+  def getCallback(converter: FileConverter): AnalysisCallback3 = new AnalysisCallback3 {
+    override def api(sourceFile: File, classApi: ClassLike): Unit = apis += classApi
+    override def api(sourceFile: VirtualFileRef, classApi: ClassLike): Unit = apis += classApi
+    override def apiPhaseCompleted(): Unit = {}
+    override def binaryDependency(
+      onBinaryEntry: File,
+      onBinaryClassName: String,
+      fromClassName: String,
+      fromSourceFile: File,
+      context: DependencyContext,
+    ): Unit = usedJars += onBinaryEntry.toPath
+
+    override def binaryDependency(
+      onBinaryEntry: Path,
+      onBinaryClassName: String,
+      fromClassName: String,
+      fromSourceFile: VirtualFileRef,
+      context: DependencyContext,
+    ): Unit = usedJars += onBinaryEntry
+
+    override def classDependency(onClassName: String, sourceClassName: String, context: DependencyContext): Unit = {}
+    override def classesInOutputJar(): java.util.Set[String] = java.util.Collections.emptySet()
+    override def dependencyPhaseCompleted(): Unit = {}
+    override def enabled(): Boolean = true
+    override def generatedLocalClass(source: File, classFile: File): Unit = {}
+    override def generatedLocalClass(source: VirtualFileRef, classFile: Path): Unit = {}
+    override def generatedNonLocalClass(
+      source: File,
+      classFile: File,
+      binaryClassName: String,
+      sourceClassName: String,
+    ): Unit = {}
+
+    override def generatedNonLocalClass(
+      source: VirtualFileRef,
+      classFile: Path,
+      binaryClassName: String,
+      sourceClassName: String,
+    ): Unit = {}
+
+    override def getPickleJarPair: Optional[T2[Path, Path]] = Optional.empty()
+
+    /**
+     * I don't really understand what this is supposed to do. It doesn't seem to be used in the Scala 3 compiler; the
+     * only place I could find it being used is the Scala 2 compiler bridge (the implementation of the compiler
+     * interface for Scala 2):
+     * [[https://github.com/sbt/zinc/blob/75d54b672adbbda1b528f5759235704de1ba333f/internal/compiler-bridge/src/main/scala/xsbt/CompilerBridge.scala#L196]]
+     *
+     * It seems that when there are compilation problems, the Scala 2 compiler bridge invokes this method, shoves the
+     * result in a `xsbt.InterfaceCompileFailed2`, throws that exception. That doesn't seem very useful, since we
+     * could've just called it ourselves.
+     */
+    override def getSourceInfos: ReadSourceInfos = SourceInfos.empty
+    override def isPickleJava: Boolean = false
+    override def mainClass(sourceFile: File, className: String): Unit = mainClasses += className
+    override def mainClass(sourceFile: VirtualFileRef, className: String): Unit = mainClasses += className
+    override def problem(what: String, pos: Position, message: String, severity: Severity, reported: Boolean): Unit = {}
+    override def problem2(
+      what: String,
+      position: Position,
+      message: String,
+      severity: Severity,
+      reported: Boolean,
+      rendered: Optional[String],
+      diagnosticCode: Optional[DiagnosticCode],
+      diagnosticRelatedInformation: util.List[DiagnosticRelatedInformation],
+      actions: util.List[Action],
+    ): Unit = {}
+
+    override def startSource(source: File): Unit = {}
+    override def startSource(source: VirtualFile): Unit = {}
+    override def toVirtualFile(path: Path): VirtualFile = converter.toVirtualFile(path)
+    override def usedName(className: String, name: String, useScopes: java.util.EnumSet[UseScope]): Unit = {}
+  }
+}

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/BUILD

@@ -12,6 +12,7 @@ scala_binary(
         "//src/main/scala/higherkindness/rules_scala/common/interrupt",
         "//src/main/scala/higherkindness/rules_scala/common/worker",
         "//src/main/scala/higherkindness/rules_scala/workers/common",
+        "//src/main/scala/sbt/internal/inc/classfile",
         "//third_party/bazel/src/java_tools/buildjar/java/com/google/devtools/build/buildjar/jarhelper",
     ],
 )