[sbt-bridge] Upgrade to CompilerInterface2

Author: adpi2

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

@@ -9,10 +9,11 @@ import core.Contexts._
 import core.{MacroClassLoader, Mode, TypeError}
 import core.StdNames.nme
 import dotty.tools.dotc.ast.Positioned
-import dotty.tools.io.File
+import dotty.tools.io.{File, AbstractFile}
 import reporting._
 import core.Decorators._
 import config.Feature
+import util.SourceFile
 
 import scala.util.control.NonFatal
 import fromtasty.{TASTYCompiler, TastyFileUtil}
@@ -31,35 +32,48 @@ class Driver {
 
   protected def emptyReporter: Reporter = new StoreReporter(null)
 
-  protected def doCompile(compiler: Compiler, fileNames: List[String])(using Context): Reporter =
-    if (fileNames.nonEmpty)
+  protected def doCompile(compiler: Compiler, fileNames: List[String])(using ctx: Context): Reporter =
+    if fileNames.nonEmpty then
       try
         val run = compiler.newRun
         run.compile(fileNames)
-
-        def finish(run: Run)(using Context): Unit =
-          run.printSummary()
-          if !ctx.reporter.errorsReported && run.suspendedUnits.nonEmpty then
-            val suspendedUnits = run.suspendedUnits.toList
-            if (ctx.settings.XprintSuspension.value)
-              report.echo(i"compiling suspended $suspendedUnits%, %")
-            val run1 = compiler.newRun
-            for unit <- suspendedUnits do unit.suspended = false
-            run1.compileUnits(suspendedUnits)
-            finish(run1)(using MacroClassLoader.init(ctx.fresh))
-
-        finish(run)
+        finish(compiler, run)
       catch
-        case ex: FatalError  =>
+        case ex: FatalError =>
           report.error(ex.getMessage) // signals that we should fail compilation.
         case ex: TypeError =>
           println(s"${ex.toMessage} while compiling ${fileNames.mkString(", ")}")
-          throw ex
         case ex: Throwable =>
           println(s"$ex while compiling ${fileNames.mkString(", ")}")
           throw ex
     ctx.reporter
-  end doCompile
+
+  protected def doCompileFiles(compiler: Compiler,  files: List[AbstractFile])(using Context): Reporter =
+    if files.nonEmpty then
+      try
+        val run = compiler.newRun
+        run.compileFiles(files)
+        finish(compiler, run)
+      catch
+        case ex: FatalError =>
+          report.error(ex.getMessage) // signals that we should fail compilation.
+        case ex: TypeError =>
+          println(s"${ex.toMessage} while compiling ${files.map(_.path).mkString(", ")}")
+        case ex: Throwable =>
+          println(s"$ex while compiling ${files.map(_.path).mkString(", ")}")
+          throw ex
+    ctx.reporter
+
+  protected def finish(compiler: Compiler, run: Run)(using Context): Unit =
+    run.printSummary()
+    if !ctx.reporter.errorsReported && run.suspendedUnits.nonEmpty then
+      val suspendedUnits = run.suspendedUnits.toList
+      if (ctx.settings.XprintSuspension.value)
+        report.echo(i"compiling suspended $suspendedUnits%, %")
+      val run1 = compiler.newRun
+      for unit <- suspendedUnits do unit.suspended = false
+      run1.compileUnits(suspendedUnits)
+      finish(compiler, run1)(using MacroClassLoader.init(ctx.fresh))
 
   protected def initCtx: Context = (new ContextBase).initialCtx
 

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

@@ -124,16 +124,13 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** Actions that need to be performed at the end of the current compilation run */
   private var finalizeActions = mutable.ListBuffer[() => Unit]()
 
-  def compile(fileNames: List[String]): Unit = try {
+  def compile(fileNames: List[String]): Unit =
     val sources = fileNames.map(runContext.getSource(_))
     compileSources(sources)
-  }
-  catch {
-    case NonFatal(ex) =>
-      if units != null then report.echo(i"exception occurred while compiling $units%, %")
-      else report.echo(s"exception occurred while compiling ${fileNames.mkString(", ")}")
-      throw ex
-  }
+
+  def compileFiles(files: List[AbstractFile]): Unit =
+    val sources = files.map(runContext.getSource(_))
+    compileSources(sources)
 
   /** TODO: There's a fundamental design problem here: We assemble phases using `fusePhases`
    *  when we first build the compiler. But we modify them with -Yskip, -Ystop
@@ -142,10 +139,15 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  account. I think the latter would be preferable.
    */
   def compileSources(sources: List[SourceFile]): Unit =
-    if (sources forall (_.exists)) {
-      units = sources.map(CompilationUnit(_))
-      compileUnits()
-    }
+    try
+      if sources forall (_.exists) then
+        units = sources.map(CompilationUnit(_))
+        compileUnits()
+    catch
+      case NonFatal(ex) =>
+        if units != null then report.echo(i"exception occurred while compiling $units%, %")
+        else report.echo(s"exception occurred while compiling ${sources.map(_.name).mkString(", ")}")
+        throw ex
 
   def compileUnits(us: List[CompilationUnit]): Unit = {
     units = us

compiler/src/dotty/tools/dotc/config/CompilerCommand.scala

@@ -33,6 +33,12 @@ object CompilerCommand {
 
   def versionMsg: String = s"Scala compiler $versionString -- $copyrightString"
 
+  def shouldStopWithInfo(using ctx: Context) = {
+    val settings = ctx.settings
+    import settings._
+    Set(help, Xhelp, Yhelp, showPlugins, XshowPhases) exists (_.value)
+  }
+
   /** Distill arguments into summary detailing settings, errors and files to compiler */
   def distill(args: Array[String])(using Context): ArgsSummary = {
     /**
@@ -110,11 +116,6 @@ object CompilerCommand {
     def xusageMessage   = createUsageMsg("Possible advanced", shouldExplain = true, isAdvanced)
     def yusageMessage   = createUsageMsg("Possible private", shouldExplain = true, isPrivate)
 
-    def shouldStopWithInfo = {
-      import settings._
-      Set(help, Xhelp, Yhelp, showPlugins, XshowPhases) exists (_.value)
-    }
-
     def phasesMessage: String = {
       (new Compiler()).phases.map {
         case List(single) => single.phaseName

project/Build.scala

@@ -490,7 +490,7 @@ object Build {
       // get libraries onboard
       libraryDependencies ++= Seq(
         "org.scala-lang.modules" % "scala-asm" % "7.3.1-scala-1", // used by the backend
-        Dependencies.`compiler-interface`,
+        Dependencies.oldCompilerInterface, // we stick to the old version to avoid deprecation warnings
         "org.jline" % "jline-reader" % "3.15.0",   // used by the REPL
         "org.jline" % "jline-terminal" % "3.15.0",
         "org.jline" % "jline-terminal-jna" % "3.15.0" // needed for Windows
@@ -947,12 +947,14 @@ object Build {
       sources in Test := Seq(),
       scalaSource in Compile := baseDirectory.value,
       javaSource  in Compile := baseDirectory.value,
+      resourceDirectory in Compile := baseDirectory.value.getParentFile / "resources",
 
       // Referring to the other project using a string avoids an infinite loop
       // when sbt reads the settings.
       test in Test := (test in (LocalProject("scala3-sbt-bridge-tests"), Test)).value,
 
-      libraryDependencies += Dependencies.`compiler-interface` % Provided
+      // The `newCompilerInterface` is backward compatible with the `oldCompilerInterface`
+      libraryDependencies += Dependencies.newCompilerInterface % Provided
     )
 
   // We use a separate project for the bridge tests since they can only be run
@@ -967,8 +969,7 @@ object Build {
 
       // Tests disabled until zinc-api-info cross-compiles with 2.13,
       // alternatively we could just copy in sources the part of zinc-api-info we need.
-      sources in Test := Seq(),
-      // libraryDependencies += (Dependencies.`zinc-api-info` % Test).withDottyCompat(scalaVersion.value)
+      sources in Test := Seq()
     )
 
   lazy val `scala3-language-server` = project.in(file("language-server")).
@@ -1233,7 +1234,7 @@ object Build {
       // Keep in sync with inject-sbt-dotty.sbt
       libraryDependencies ++= Seq(
         Dependencies.`jackson-databind`,
-        Dependencies.`compiler-interface`
+        Dependencies.newCompilerInterface
       ),
       unmanagedSourceDirectories in Compile +=
         baseDirectory.value / "../language-server/src/dotty/tools/languageserver/config",

project/Dependencies.scala

@@ -10,7 +10,6 @@ object Dependencies {
   val `jackson-dataformat-yaml` =
     "com.fasterxml.jackson.dataformat" % "jackson-dataformat-yaml" % jacksonVersion
 
-  private val zincVersion = "1.2.5"
-  val `compiler-interface` = "org.scala-sbt" % "compiler-interface" % zincVersion
-  val `zinc-api-info` = "org.scala-sbt" %% "zinc-apiinfo" % zincVersion
+  val newCompilerInterface = "org.scala-sbt" % "compiler-interface" % "1.4.3"
+  val oldCompilerInterface = "org.scala-sbt" % "compiler-interface" % "1.3.5"
 }

project/build.sbt

@@ -10,7 +10,7 @@ unmanagedSourceDirectories in Compile += baseDirectory.value / "../sbt-dotty/src
 // Keep in sync with `sbt-dotty` config in Build.scala
 libraryDependencies ++= Seq(
   Dependencies.`jackson-databind`,
-  Dependencies.`compiler-interface`
+  Dependencies.newCompilerInterface
 )
 unmanagedSourceDirectories in Compile +=
   baseDirectory.value / "../language-server/src/dotty/tools/languageserver/config"

sbt-bridge/resources/META-INF/services/xsbti.compile.CompilerInterface2

@@ -0,0 +1 @@
+xsbt.CompilerBridge

sbt-bridge/src/xsbt/AbstractZincFile.java

@@ -0,0 +1,27 @@
+/*
+ * Zinc - The incremental compiler for Scala.
+ * Copyright Lightbend, Inc. and Mark Harrah
+ */
+
+package xsbt;
+
+import dotty.tools.io.AbstractFile;
+import xsbti.PathBasedFile;
+import xsbti.VirtualFile;
+
+import java.io.IOException;
+
+interface AbstractZincFile {
+  String id();
+
+  static AbstractFile of(VirtualFile virtualFile) {
+    if (virtualFile instanceof PathBasedFile)
+      return new ZincPlainFile((PathBasedFile) virtualFile);
+
+    try {
+      return new ZincVirtualFile(virtualFile);
+    } catch (IOException e) {
+      throw new IllegalArgumentException("invalid file " + virtualFile.name(), e);
+    }
+  }
+}

sbt-bridge/src/xsbt/CachedCompilerImpl.java

@@ -3,36 +3,28 @@
  */
 package xsbt;
 
-import xsbti.AnalysisCallback;
-import xsbti.Logger;
-import xsbti.Reporter;
-import xsbti.Severity;
+import xsbti.*;
 import xsbti.compile.*;
 
 import java.io.File;
 
 import dotty.tools.dotc.core.Contexts.Context;
 import dotty.tools.dotc.core.Contexts.ContextBase;
 import dotty.tools.dotc.Main;
-import dotty.tools.dotc.interfaces.*;
-
-import java.net.URLClassLoader;
 
 public class CachedCompilerImpl implements CachedCompiler {
   private final String[] args;
-  private final Output output;
   private final String[] outputArgs;
 
   public CachedCompilerImpl(String[] args, Output output) {
     super();
     this.args = args;
-    this.output = output;
 
     if (!(output instanceof SingleOutput))
       throw new IllegalArgumentException("output should be a SingleOutput, was a " + output.getClass().getName());
 
     this.outputArgs =
-      new String[] { "-d", ((SingleOutput) output).getOutputDirectory().getAbsolutePath().toString() };
+      new String[] { "-d", ((SingleOutput) output).getOutputDirectory().getAbsolutePath() };
   }
 
   public String[] commandArguments(File[] sources) {
@@ -54,7 +46,8 @@ public String[] commandArguments(File[] sources) {
     return result;
   }
 
-  synchronized public void run(File[] sources, DependencyChanges changes, AnalysisCallback callback, Logger log, Reporter delegate, CompileProgress progress) {
+  synchronized public void run(File[] sources, DependencyChanges changes, AnalysisCallback callback, Logger log,
+    Reporter delegate, CompileProgress progress) {
     log.debug(() -> {
       String msg = "Calling Dotty compiler with arguments  (CompilerInterface):";
       for (String arg : args)
@@ -68,7 +61,7 @@ synchronized public void run(File[] sources, DependencyChanges changes, Analysis
 
     dotty.tools.dotc.reporting.Reporter reporter = Main.process(commandArguments(sources), ctx);
     if (reporter.hasErrors()) {
-      throw new InterfaceCompileFailed(args, new Problem[0]);
+      throw new InterfaceCompileFailed(args, new Problem[0], "Compilation failed");
     }
   }
 }

sbt-bridge/src/xsbt/CompilerBridge.java

@@ -0,0 +1,25 @@
+/*
+ * Zinc - The incremental compiler for Scala.
+ * Copyright Lightbend, Inc. and Mark Harrah
+ */
+
+package xsbt;
+
+import dotty.tools.dotc.Driver;
+import xsbti.AnalysisCallback;
+import xsbti.Logger;
+import xsbti.Reporter;
+import xsbti.VirtualFile;
+import xsbti.compile.CompileProgress;
+import xsbti.compile.CompilerInterface2;
+import xsbti.compile.DependencyChanges;
+import xsbti.compile.Output;
+
+public final class CompilerBridge extends Driver implements CompilerInterface2 {
+  @Override
+  public void run(VirtualFile[] sources, DependencyChanges changes, String[] options, Output output,
+    AnalysisCallback callback, Reporter delegate, CompileProgress progress, Logger log) {
+    CompilerBridgeDriver driver = new CompilerBridgeDriver(options, output);
+    driver.run(sources, callback, log, delegate);
+  }
+}