IDE tests: compile dependent workspaces

When writing IDE tests that simulate multi-project setups, we need to
compile the sources of the workspaces that are depended on, because the
dependent workspaces require their class files.

This commit changes the `TestServer` so that workspaces that are
depended on are compiled during the initialization of the server. When
there are no dependency relation between workspaces, no compilation is
performed.

Author: Duhemm

language-server/test/dotty/tools/languageserver/util/CodeTester.scala

@@ -18,9 +18,11 @@ class CodeTester(workspaces: List[Workspace]) {
   private val sources = for { workspace <- workspaces
                               source <- workspace.sources } yield (workspace, source)
 
-  private val files = sources.zipWithIndex.map { case ((workspace, source), i) =>
-    testServer.openCode(source.text, workspace, s"Source${i}.scala")
-  }
+  private val files =
+    for { workspace <- workspaces
+          (source, id) <- workspace.sources.zipWithIndex } yield {
+      testServer.openCode(source.text, workspace, s"Source${id}.scala")
+    }
 
   private val positions: PositionContext = getPositions(files)
 

language-server/test/dotty/tools/languageserver/util/server/TestServer.scala

@@ -1,11 +1,14 @@
 package dotty.tools.languageserver.util.server
 
 import java.io.PrintWriter
-import java.io.File.{separator => sep}
+import java.io.File.{pathSeparator, separator}
 import java.net.URI
 import java.nio.file.{Files, Path}
 import java.util
 
+import dotty.tools.dotc.Main
+import dotty.tools.dotc.reporting.{Reporter, ThrowingReporter}
+import dotty.tools.io.Directory
 import dotty.tools.languageserver.DottyLanguageServer
 import dotty.tools.languageserver.util.Code.Workspace
 import org.eclipse.lsp4j.{ DidOpenTextDocumentParams, InitializeParams, InitializeResult, TextDocumentItem}
@@ -16,41 +19,38 @@ class TestServer(testFolder: Path, workspaces: List[Workspace]) {
   init()
 
   private[this] def init(): InitializeResult = {
+    var compiledWorkspaces: Set[Workspace] = Set.empty
+
+    /** Compile the dependencies of the given workspace, and then the workspace. */
+    def compileWorkspaceAndDependencies(workspace: Workspace): Unit =
+      if (!compiledWorkspaces.contains(workspace)) {
+        workspace.dependsOn.foreach(compileWorkspaceAndDependencies)
+        compileWorkspace(workspace)
+        compiledWorkspaces += workspace
+      }
+
     /**
      * Set up given workspace, return JSON config.
      *
-     * This creates the necessary directories to hold the classes and sources. Some values
-     * are passed via sbt-buildinfo, such as the classpath containing the scala and dotty libaries.
+     * If the workspace has dependencies, these dependencies are compiled. The classfiles of the
+     * dependent workspaces are put on the classpath of this workspace.
      *
      * @param workspace The workspace to configure.
      * @return A JSON object representing the configuration for this workspace.
      */
     def workspaceSetup(workspace: Workspace): String = {
       def showSeq[T](lst: Seq[T]): String = lst.map(elem => '"' + elem.toString + '"').mkString("[ ", ", ", " ]")
 
-      def classDirectory(workspace: Workspace): Path = {
-        val path = testFolder.resolve(workspace.name).resolve("out")
-        Files.createDirectories(path)
-        path.toAbsolutePath
-      }
-
-      val dependencyClasspath =
-        BuildInfo.ideTestsDependencyClasspath.map(_.getAbsolutePath) ++
-          workspace.dependsOn.map(w => classDirectory(w).toString)
-
-      val sourceDirectory: Path = {
-        val path = TestFile.sourceDir.resolve(workspace.name).toAbsolutePath
-        Files.createDirectories(path)
-        path
-      }
+      // Compile all the dependencies of this workspace
+      workspace.dependsOn.foreach(compileWorkspaceAndDependencies)
 
       s"""{
          |  "id" : "${workspace.name}",
          |  "compilerVersion" : "${BuildInfo.ideTestsCompilerVersion}",
          |  "compilerArguments" : ${showSeq(BuildInfo.ideTestsCompilerArguments)},
-         |  "sourceDirectories" : ${showSeq(sourceDirectory :: Nil)},
-         |  "dependencyClasspath" : ${showSeq(dependencyClasspath)},
-         |  "classDirectory" : "${classDirectory(workspace)}"
+         |  "sourceDirectories" : ${showSeq(sourceDirectory(workspace, wipe = false) :: Nil)},
+         |  "dependencyClasspath" : ${showSeq(dependencyClasspath(workspace))},
+         |  "classDirectory" : "${classDirectory(workspace, wipe = false)}"
          |}
          |""".stripMargin
     }
@@ -78,7 +78,7 @@ class TestServer(testFolder: Path, workspaces: List[Workspace]) {
    *  @return the file opened
    */
   def openCode(code: String, workspace: Workspace, fileName: String): TestFile = {
-    val testFile = new TestFile(workspace.name + sep + fileName)
+    val testFile = new TestFile(workspace.name + separator + fileName)
     val dotdp = new DidOpenTextDocumentParams()
     val tdi = new TextDocumentItem()
     tdi.setUri(testFile.uri)
@@ -88,4 +88,50 @@ class TestServer(testFolder: Path, workspaces: List[Workspace]) {
     testFile
   }
 
+  private def classDirectory(workspace: Workspace, wipe: Boolean): Path = {
+    val path = testFolder.resolve(workspace.name).resolve("out")
+    if (wipe) {
+      Directory(path).deleteRecursively()
+      Files.createDirectories(path)
+    }
+    path.toAbsolutePath
+  }
+
+  private def dependencyClasspath(workspace: Workspace) =
+    BuildInfo.ideTestsDependencyClasspath.map(_.getAbsolutePath) ++
+      workspace.dependsOn.map(w => classDirectory(w, wipe = false).toString)
+
+  private def sourceDirectory(workspace: Workspace, wipe: Boolean): Path = {
+    val path = TestFile.sourceDir.resolve(workspace.name).toAbsolutePath
+    if (wipe) {
+      Directory(path).deleteRecursively()
+      Files.createDirectories(path)
+    }
+    path
+  }
+
+  /**
+   * Sets up the sources of the given workspace, creates the necessary directories
+   * and compile the sources.
+   *
+   * @param workspace The workspace to set up.
+   */
+  private def compileWorkspace(workspace: Workspace): Unit = {
+    val sourcesDir = sourceDirectory(workspace, wipe = true)
+    val sources = workspace.sources.zipWithIndex.map { case (src, id) =>
+      val path = sourcesDir.resolve(s"Source${id}.scala").toAbsolutePath
+      Files.write(path, src.text.getBytes("UTF-8"))
+      path.toString
+    }
+
+    val compileOptions =
+      sources.toArray ++
+        Array(
+          "-classpath", dependencyClasspath(workspace).mkString(pathSeparator),
+          "-d", classDirectory(workspace, wipe = true).toString
+        )
+    val reporter = new ThrowingReporter(Reporter.NoReporter)
+    Main.process(compileOptions, reporter)
+  }
+
 }