Support multi-project setups in the IDE tests

Author: Duhemm

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

@@ -74,8 +74,11 @@ object Code {
     }
   }
 
-  /** A new `CodeTester` working with `sources` in the workspace. */
-  def withSources(sources: SourceWithPositions*): CodeTester = new CodeTester(sources.toList, Nil)
+  /** A new `CodeTester` working with a single workspace containing `sources`. */
+  def withSources(sources: SourceWithPositions*): CodeTester = withWorkspaces(Workspace(sources.toList))
+
+  /** A new `CodeTester` working with `workspaces`. */
+  def withWorkspaces(workspaces: Workspace*): CodeTester = new CodeTester(workspaces.toList)
 
   /**
    * A virtual source file where several markers have been set.
@@ -85,7 +88,46 @@ object Code {
    */
   case class SourceWithPositions(text: String, positions: List[(CodeMarker, Int, Int)]) {
     /** A new `CodeTester` with only this source in the workspace. */
-    def withSource: CodeTester = new CodeTester(this :: Nil, Nil)
+    def withSource: CodeTester = withSources(this)
+  }
+
+  /**
+   * A group of sources belonging to the same project.
+   *
+   * @param sources   The sources that this workspace holds.
+   * @param name      The name of this workspace
+   * @param dependsOn The other workspaces on which this workspace depend.
+   */
+  case class Workspace(sources: List[SourceWithPositions],
+                       name: String = Workspace.freshName,
+                       dependsOn: List[Workspace] = Nil) {
+
+    /**
+     * Add `sources` to the sources of this workspace.
+     */
+    def withSources(sources: SourceWithPositions*): Workspace = copy(sources = this.sources ::: sources.toList)
+
+  }
+
+  object Workspace {
+    private[this] val count = new java.util.concurrent.atomic.AtomicInteger()
+    private def freshName: String = s"workspace${count.incrementAndGet()}"
+
+    /**
+     * Creates a new workspace that depends on `workspaces`.
+     *
+     * @param workspaces The dependencies of the new workspace.
+     * @return An empty workspace with a dependency on the specified workspaces.
+     */
+    def dependingOn(workspaces: Workspace*) = new Workspace(Nil, dependsOn = workspaces.toList)
+
+    /**
+     * Create a new workspace with the given sources.
+     *
+     * @param sources The sources to add to this workspace.
+     * @return a new workspace containing the specified sources.
+     */
+    def withSources(sources: SourceWithPositions*): Workspace = new Workspace(sources.toList)
   }
 
 }

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

@@ -1,6 +1,6 @@
 package dotty.tools.languageserver.util
 
-import dotty.tools.languageserver.util.Code.SourceWithPositions
+import dotty.tools.languageserver.util.Code.{SourceWithPositions, Workspace}
 import dotty.tools.languageserver.util.actions._
 import dotty.tools.languageserver.util.embedded.CodeMarker
 import dotty.tools.languageserver.util.server.{TestFile, TestServer}
@@ -10,15 +10,18 @@ import org.eclipse.lsp4j.{CompletionItemKind, DocumentHighlightKind}
  * Simulates an LSP client for test in a workspace defined by `sources`.
  *
  * @param sources The list of sources in the workspace
- * @param actions Unused
  */
-class CodeTester(sources: List[SourceWithPositions], actions: List[Action]) {
+class CodeTester(workspaces: List[Workspace]) {
 
-  private val testServer = new TestServer(TestFile.testDir)
+  private val testServer = new TestServer(TestFile.testDir, workspaces)
 
-  private val files = sources.zipWithIndex.map { case (code, i) =>
-    testServer.openCode(code.text, s"Source$i.scala")
+  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 positions: PositionContext = getPositions(files)
 
   /**
@@ -121,7 +124,13 @@ class CodeTester(sources: List[SourceWithPositions], actions: List[Action]) {
       action.execute()(testServer, positions)
     } catch {
       case ex: AssertionError =>
-        val sourcesStr = sources.zip(files).map{ case (source, file) => "// " + file.file + "\n" + source.text}.mkString("\n")
+        val sourcesStr =
+          sources.zip(files).map {
+            case ((workspace, source), file) =>
+              s"""// ${file.file} in workspace ${workspace.name}
+                 |${source.text}""".stripMargin
+          }.mkString(System.lineSeparator)
+
         val msg =
           s"""
             |
@@ -140,7 +149,7 @@ class CodeTester(sources: List[SourceWithPositions], actions: List[Action]) {
   private def getPositions(files: List[TestFile]): PositionContext = {
     val posSeq = {
       for {
-        (code, file) <- sources.zip(files)
+        ((_, code), file) <- sources.zip(files)
         (position, line, char) <- code.positions
       } yield position -> (file, line, char)
     }

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

@@ -1,38 +1,65 @@
 package dotty.tools.languageserver.util.server
 
 import java.io.PrintWriter
+import java.io.File.{separator => sep}
 import java.net.URI
-import java.nio.file.Path
+import java.nio.file.{Files, Path}
 import java.util
 
 import dotty.tools.languageserver.DottyLanguageServer
+import dotty.tools.languageserver.util.Code.Workspace
 import org.eclipse.lsp4j.{ DidOpenTextDocumentParams, InitializeParams, InitializeResult, TextDocumentItem}
 
-class TestServer(testFolder: Path) {
+class TestServer(testFolder: Path, workspaces: List[Workspace]) {
 
   val server = new DottyLanguageServer
   init()
 
   private[this] def init(): InitializeResult = {
-    // Fill the configuration with values populated by sbt
-    def showSeq[T](lst: Seq[T]): String = lst.map(elem => '"' + elem.toString + '"').mkString("[ ", ", ", " ]")
-    val dottyIdeJson: String =
-      s"""[ {
-         |  "id" : "dotty-ide-test",
+    /**
+     * 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.
+     *
+     * @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
+      }
+
+      s"""{
+         |  "id" : "${workspace.name}",
          |  "compilerVersion" : "${BuildInfo.ideTestsCompilerVersion}",
          |  "compilerArguments" : ${showSeq(BuildInfo.ideTestsCompilerArguments)},
-         |  "sourceDirectories" : ${showSeq(BuildInfo.ideTestsSourceDirectories)},
-         |  "dependencyClasspath" : ${showSeq(BuildInfo.ideTestsDependencyClasspath)},
-         |  "classDirectory" : "${BuildInfo.ideTestsClassDirectory}"
+         |  "sourceDirectories" : ${showSeq(sourceDirectory :: Nil)},
+         |  "dependencyClasspath" : ${showSeq(dependencyClasspath)},
+         |  "classDirectory" : "${classDirectory(workspace)}"
          |}
-         |]""".stripMargin
+         |""".stripMargin
+    }
+
     val configFile = testFolder.resolve(DottyLanguageServer.IDE_CONFIG_FILE)
-    testFolder.toFile.mkdirs()
-    testFolder.resolve("src").toFile.mkdirs()
-    testFolder.resolve("out").toFile.mkdirs()
+    val configuration = workspaces.map(workspaceSetup).mkString("[", ",", "]")
 
     new PrintWriter(configFile.toString) {
-      write(dottyIdeJson)
+      write(configuration)
       close()
     }
 
@@ -49,8 +76,8 @@ class TestServer(testFolder: Path) {
    *  @param fileName file path in the source directory
    *  @return the file opened
    */
-  def openCode(code: String, fileName: String): TestFile = {
-    val testFile = new TestFile(fileName)
+  def openCode(code: String, workspace: Workspace, fileName: String): TestFile = {
+    val testFile = new TestFile(workspace.name + sep + fileName)
     val dotdp = new DidOpenTextDocumentParams()
     val tdi = new TextDocumentItem()
     tdi.setUri(testFile.uri)