Make configureIDE work with crossScalaVersions

So far, configureIDE detected the dotty-compiled projects by looking at
`scalaVersion`, with this commit we now also look at
`crossScalaVersions`. This is considerably harder to do since extracting
the settings requires updating `scalaVersion` in all projects where it's
not set to a dotty version but `crossScalaVersion` is, moreover this
update needs to be temporary: once the `configureIDE` task is done, the
state should revert to the original one.

Author: smarter

sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala

@@ -14,7 +14,7 @@ import DottyPlugin.autoImport._
 
 object DottyIDEPlugin extends AutoPlugin {
   // Adapted from scala-reflect
-  private[this] def distinctBy[A, B](xs: Seq[A])(f: A => B): Seq[A] = {
+  private def distinctBy[A, B](xs: Seq[A])(f: A => B): Seq[A] = {
     val buf = new mutable.ListBuffer[A]
     val seen = mutable.Set[B]()
     xs foreach { x =>
@@ -27,20 +27,102 @@ object DottyIDEPlugin extends AutoPlugin {
     buf.toList
   }
 
-  private def inAllDottyConfigurations[A](key: TaskKey[A], state: State): Task[Seq[A]] = {
-    val struct = Project.structure(state)
-    val settings = struct.data
-    struct.allProjectRefs.flatMap { projRef =>
-      val project = Project.getProjectForReference(projRef, struct).get
+  private def isDottyVersion(version: String) =
+    version.startsWith("0.")
+
+
+  /** Return a new state derived from `state` such that scalaVersion returns `newScalaVersion` in all
+   *  projects in `projRefs` (`state` is returned if no setting needed to be updated).
+   */
+  private def updateScalaVersion(state: State, projRefs: Seq[ProjectRef], newScalaVersion: String): State = {
+    val extracted = Project.extract(state)
+    val settings = extracted.structure.data
+
+    if (projRefs.forall(projRef => scalaVersion.in(projRef).get(settings).get == newScalaVersion))
+      state
+    else {
+      def matchingSetting(setting: Setting[_]) =
+        setting.key.key == scalaVersion.key &&
+        setting.key.scope.project.fold(ref => projRefs.contains(ref), ifGlobal = true, ifThis = true)
+
+      val newSettings = extracted.session.mergeSettings.collect {
+        case setting if matchingSetting(setting) =>
+          scalaVersion in setting.key.scope := newScalaVersion
+      }
+      val newSession = extracted.session.appendRaw(newSettings)
+      BuiltinCommands.reapply(newSession, extracted.structure, state)
+    }
+  }
+
+  /** Setup to run in all dotty projects.
+   *  Return a triplet of:
+   *  (1) A version of dotty
+   *  (2) A list of dotty projects
+   *  (3) A state where `scalaVersion` is set to (1) in all projects in (2)
+   */
+  private def dottySetup(state: State): (String, Seq[ProjectRef], State) = {
+    val structure = Project.structure(state)
+    val settings = structure.data
+
+    // FIXME: this function uses `sorted` to order versions but this is incorrect,
+    // we need an Ordering for version numbers, like the one in Coursier.
+
+    val (dottyVersions, dottyProjRefs) =
+      structure.allProjectRefs.flatMap { projRef =>
+        val version = scalaVersion.in(projRef).get(settings).get
+        if (isDottyVersion(version))
+          Some((version, projRef))
+        else
+          crossScalaVersions.in(projRef).get(settings).get.filter(isDottyVersion).sorted.lastOption match {
+            case Some(v) =>
+              Some((v, projRef))
+            case _ =>
+              None
+          }
+      }.unzip
+
+    if (dottyVersions.isEmpty)
+      throw new FeedbackProvidedException {
+        override def toString = "No Dotty project detected"
+      }
+    else {
+      val dottyVersion = dottyVersions.sorted.last
+      val dottyState = updateScalaVersion(state, dottyProjRefs, dottyVersion)
+      (dottyVersion, dottyProjRefs, dottyState)
+    }
+  }
+
+  /** Run `task` in state `state` */
+  private def runTask[T](task: Task[T], state: State): T = {
+    val extracted = Project.extract(state)
+    val structure = extracted.structure
+    val (_, result) =
+      EvaluateTask.withStreams(structure, state) { streams =>
+        EvaluateTask.runTask(task, state, streams, structure.index.triggers,
+          EvaluateTask.extractedTaskConfig(extracted, structure, state))(
+          EvaluateTask.nodeView(state, streams, Nil)
+        )
+      }
+    result match {
+      case Value(v) =>
+        v
+      case Inc(i) =>
+        throw i
+    }
+  }
+
+  /** Run task `key` in all configurations in all projects in `projRefs`, using state `state` */
+  private def runInAllConfigurations[T](key: TaskKey[T], projRefs: Seq[ProjectRef], state: State): Seq[T] = {
+    val structure = Project.structure(state)
+    val settings = structure.data
+    val joinedTask = projRefs.flatMap { projRef =>
+      val project = Project.getProjectForReference(projRef, structure).get
       project.configurations.flatMap { config =>
-        isDotty.in(projRef, config).get(settings) match {
-          case Some(true) =>
-            key.in(projRef, config).get(settings)
-          case _ =>
-            None
-        }
+        key.in(projRef, config).get(settings)
       }
     }.join
+
+    runTask(joinedTask, state)
   }
 
   private val projectConfig = taskKey[Option[ProjectConfig]]("")
@@ -57,6 +139,7 @@ object DottyIDEPlugin extends AutoPlugin {
   override def requires: Plugins = plugins.JvmPlugin
   override def trigger = allRequirements
 
+
   override def projectSettings: Seq[Setting[_]] = Seq(
     // Use Def.derive so `projectConfig` is only defined in the configurations where the
     // tasks/settings it depends on are defined.
@@ -70,7 +153,6 @@ object DottyIDEPlugin extends AutoPlugin {
 
         val id = s"${thisProject.value.id}/${configuration.value.name}"
         val compilerVersion = scalaVersion.value
-          .replace("-nonbootstrapped", "") // The language server is only published bootstrapped
         val compilerArguments = scalacOptions.value
         val sourceDirectories = unmanagedSourceDirectories.value ++ managedSourceDirectories.value
         val depClasspath = Attributed.data(dependencyClasspath.value)
@@ -89,40 +171,40 @@ object DottyIDEPlugin extends AutoPlugin {
   )
 
   override def buildSettings: Seq[Setting[_]] = Seq(
-    configureIDE := {
-      val log = streams.value.log
-
-      val configs0 = state.flatMap(s =>
-        inAllDottyConfigurations(projectConfig, s)
-      ).value.flatten
-      // Drop configurations who do not define their own sources, but just
-      // inherit their sources from some other configuration.
-      val configs = distinctBy(configs0)(_.sourceDirectories.deep)
-
-      if (configs.isEmpty) {
-        log.error("No Dotty project detected")
-      } else {
-        // If different versions of Dotty are used by subprojects, choose the latest one
-        // FIXME: use a proper version number Ordering that knows that "0.1.1-M1" < "0.1.1"
-        val ideVersion = configs.map(_.compilerVersion).sorted.last
+    configureIDE := Def.taskDyn {
+      val origState = state.value
+      Def.task {
+        val (dottyVersion, projRefs, dottyState) = dottySetup(origState)
+        val configs0 = runInAllConfigurations(projectConfig, projRefs, dottyState).flatten
+
+        // Drop configurations that do not define their own sources, but just
+        // inherit their sources from some other configuration.
+        val configs = distinctBy(configs0)(_.sourceDirectories.deep)
+
         // Write the version of the Dotty Language Server to use in a file by itself.
         // This could be a field in the JSON config file, but that would require all
         // IDE plugins to parse JSON.
+        val dlsVersion = dottyVersion
+          .replace("-nonbootstrapped", "") // The language server is only published bootstrapped
+        val dlsBinaryVersion = dlsVersion.split("\\.").take(2).mkString(".")
         val pwArtifact = new PrintWriter(".dotty-ide-artifact")
-        pwArtifact.println(s"ch.epfl.lamp:dotty-language-server_0.1:${ideVersion}")
+        pwArtifact.println(s"ch.epfl.lamp:dotty-language-server_${dlsBinaryVersion}:${dlsVersion}")
         pwArtifact.close()
 
         val mapper = new ObjectMapper
         mapper.writerWithDefaultPrettyPrinter()
           .writeValue(new File(".dotty-ide.json"), configs.toArray)
       }
-    },
-
-    compileForIDE := {
-      val _ = state.flatMap(s =>
-        inAllDottyConfigurations(compile, s)
-      ).value
-    },
+    }.value,
+
+    compileForIDE := Def.taskDyn {
+      val origState = state.value
+      Def.task {
+        val (dottyVersion, projRefs, dottyState) = dottySetup(origState)
+        runInAllConfigurations(compile, projRefs, dottyState)
+        ()
+      }
+    }.value,
 
     runCode := {
       val exitCode = new ProcessBuilder("code", "--install-extension", "lampepfl.dotty")