Restore the test for #2202 (concurrent use of the linker).

The previous test had basically been inhibited when we switched
the default environment from Rhino to Node.js. Indeed, this caused
`loadedJSEnv` not to use the linker itself, but rather depend on
the result of `fastOptJS`. The test was therefore not testing
anything anymore.

We restore this test in a more explicit and robust way, with a
custom task to concurrently use the linker of `fullOptJS`, and a
dedicated test task to directly depend on the former + `fullOptJS`.
We use `fullOptJS` instead of `fastOptJS` because it takes more
time, increasing the likelihood of concurrent execution.

Author: sjrd

sbt-plugin-test/build.sbt

@@ -1,5 +1,11 @@
+import org.scalajs.core.tools.io._
 import org.scalajs.core.tools.jsdep.ManifestFilters
 import org.scalajs.jsenv.nodejs.JSDOMNodeJSEnv
+import org.scalajs.sbtplugin.ScalaJSPluginInternal._
+import org.scalajs.sbtplugin.Loggers.sbtLogger2ToolsLogger
+
+lazy val concurrentFakeFullOptJS = taskKey[Any]("")
+lazy val concurrentUseOfLinkerTest = taskKey[Any]("")
 
 name := "Scala.js sbt test"
 
@@ -56,7 +62,32 @@ lazy val noDOM = project.settings(baseSettings: _*).
   /* This hopefully exposes concurrent uses of the linker. If it fails/gets
    * flaky, there is a bug somewhere - #2202
    */
-  settings(inConfig(Compile)(run <<= run.dependsOn(fastOptJS, loadedJSEnv)): _*)
+  settings(inConfig(Compile)(Seq(
+      // A fake fullOptJS that we will run concurrently with the true fullOptJS
+      concurrentFakeFullOptJS := Def.taskDyn {
+        val s = (streams in fullOptJS).value
+        val log = s.log
+        val ir = (scalaJSIR in fullOptJS).value.data
+        val moduleInitializers = scalaJSModuleInitializers.value
+
+        Def.task {
+          log.info("Fake full optimizing")
+          val linker = (scalaJSLinker in fullOptJS).value
+          linker.link(ir, moduleInitializers,
+              WritableMemVirtualJSFile("fake-fastopt.js"),
+              sbtLogger2ToolsLogger(log))
+        }.tag((usesScalaJSLinkerTag in fullOptJS).value)
+      }.value,
+
+      /* Depend on both fullOptJS and concurrentFakeFullOptJS, so that they
+       * are hopefully executed in parallel (potentially, but they should be
+       * blocked from actually doing so by the concurrent restrictions on
+       * usesScalaJSLinkerTag).
+       */
+      concurrentUseOfLinkerTest := {
+        (fullOptJS.value, concurrentFakeFullOptJS.value)
+      }
+  )))
 
 lazy val withDOM = project.settings(baseSettings: _*).
   enablePlugins(ScalaJSPlugin).