Use scripted for concurrent linker test

This is so that the main sbt-plugin-test does not have a direct
dependency on the Linker anymore (see scala-js#3805 for details).

Author: gzm0

Jenkinsfile

@@ -364,7 +364,8 @@ def Tasks = [
         linker/compile:doc jsEnvs/compile:doc \
         jsEnvsTestKit/compile:doc nodeJSEnv/compile:doc \
         testAdapter/compile:doc \
-        sbtPlugin/compile:doc
+        sbtPlugin/compile:doc &&
+    sbt sbtPlugin/scripted
   ''',
 
   "partestc": '''
@@ -393,7 +394,7 @@ def Tasks = [
         noDOM/testHtml multiTestJS/testHtml \
         test \
         noDOM/testScalaJSModuleInitializers \
-        noDOM/clean noDOM/concurrentUseOfLinkerTest \
+        noDOM/clean \
         multiTestJS/test:testScalaJSSourceMapAttribute &&
     sbt 'set scalaJSStage in Global := FullOptStage' \
         noDOM/testHtml multiTestJS/testHtml

project/Build.scala

@@ -9,6 +9,7 @@ import Keys._
 
 import com.typesafe.tools.mima.plugin.MimaPlugin.autoImport._
 import de.heikoseeberger.sbtheader.HeaderPlugin.autoImport._
+import ScriptedPlugin.autoImport._
 
 import java.util.Arrays
 
@@ -784,7 +785,8 @@ object Build {
         baseDirectory.value.getParentFile / "test-common/src/test/scala"
   ).dependsOn(jsEnvs, jUnitAsyncJVM % "test")
 
-  lazy val plugin: Project = Project(id = "sbtPlugin", base = file("sbt-plugin")).settings(
+  lazy val plugin: Project = Project(id = "sbtPlugin", base = file("sbt-plugin"))
+      .enablePlugins(ScriptedPlugin).settings(
       commonSettings,
       publishIvySettings,
       fatalWarningsSettings,
@@ -801,6 +803,37 @@ object Build {
 
       addSbtPlugin("org.portable-scala" % "sbt-platform-deps" % "1.0.0"),
 
+      scriptedLaunchOpts += "-Dplugin.version=" + version.value,
+
+      scriptedLaunchOpts ++= {
+        // Forward Ivy home options.
+        for {
+          o <- Seq("sbt.boot.directory", "sbt.ivy.home", "ivy.home", "sbt.global.base")
+          v <- sys.props.get(o)
+        } yield {
+          s"-D$o=$v"
+        }
+      },
+
+      scriptedDependencies := {
+        scriptedDependencies.dependsOn(
+            publishLocal in compiler,
+            publishLocal in library,
+            publishLocal in testInterface,
+            publishLocal in testBridge,
+            publishLocal in jUnitPlugin,
+            publishLocal in jUnitRuntime,
+            publishLocal in irProject,
+            publishLocal in logging,
+            publishLocal in linkerInterface,
+            publishLocal in linker,
+            publishLocal in jsEnvs,
+            publishLocal in nodeJSEnv,
+            publishLocal in testAdapter,
+            publishLocal in jsEnvs,
+        ).value
+      },
+
       // Add API mappings for sbt (seems they don't export their API URL)
       apiMappings ++= {
         val deps = (externalDependencyClasspath in Compile).value

sbt-plugin-test/build.sbt

@@ -1,14 +1,6 @@
-import scala.concurrent.Await
-import scala.concurrent.duration.Duration
-
-import org.scalajs.linker.MemOutputFile
-import org.scalajs.linker.interface._
-import org.scalajs.sbtplugin.Loggers.sbtLogger2ToolsLogger
+import org.scalajs.linker.interface.ModuleInitializer
 import org.scalajs.sbtplugin.ScalaJSCrossVersion
 
-lazy val concurrentFakeFullOptJS = taskKey[Any]("")
-lazy val concurrentUseOfLinkerTest = taskKey[Any]("")
-
 name := "Scala.js sbt test"
 
 version := scalaJSVersion
@@ -56,39 +48,7 @@ lazy val noDOM = project.settings(baseSettings: _*).
       assert((scalaJSModuleInitializers in Test).value.size == 3,
         "Bad number of scalaJSModuleInitializers in Test")
     }
-  ).
-  /* This hopefully exposes concurrent uses of the linker. If it fails/gets
-   * flaky, there is a bug somewhere - #2202
-   */
-  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 {
-          import scala.concurrent.ExecutionContext.Implicits.global
-
-          log.info("Fake full optimizing")
-          val linker = (scalaJSLinker in fullOptJS).value
-          val output = LinkerOutput(MemOutputFile())
-          Await.result(
-              linker.link(ir, moduleInitializers, output, sbtLogger2ToolsLogger(log)),
-              Duration.Inf)
-        }.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 testFrameworkCommonSettings = Def.settings(
   versionSettings,

sbt-plugin/src/sbt-test/linker-tags/concurrent-linker-use/Main.scala

@@ -0,0 +1,5 @@
+package org.scalajs.sbtplugin.test
+
+object Main {
+  def main(args: Array[String]): Unit = println("Hello World")
+}

sbt-plugin/src/sbt-test/linker-tags/concurrent-linker-use/build.sbt

@@ -0,0 +1,48 @@
+import scala.concurrent.Await
+import scala.concurrent.duration.Duration
+
+import org.scalajs.linker.MemOutputFile
+import org.scalajs.linker.interface._
+import org.scalajs.sbtplugin.Loggers.sbtLogger2ToolsLogger
+
+lazy val concurrentFakeFullOptJS = taskKey[Any]("")
+lazy val concurrentUseOfLinkerTest = taskKey[Any]("")
+
+name := "Scala.js sbt test"
+
+version := scalaJSVersion
+scalaVersion := "2.12.8"
+
+enablePlugins(ScalaJSPlugin)
+
+/* This hopefully exposes concurrent uses of the linker. If it fails/gets
+ * flaky, there is a bug somewhere - #2202
+ */
+
+// A fake fullOptJS that we will run concurrently with the true fullOptJS
+concurrentFakeFullOptJS := Def.taskDyn {
+  val log = streams.value.log
+  val ir = (scalaJSIR in Compile).value.data
+  val moduleInitializers = (scalaJSModuleInitializers in Compile).value
+
+  Def.task {
+    import scala.concurrent.ExecutionContext.Implicits.global
+
+    log.info("Fake full optimizing")
+    val linker = (scalaJSLinker in Compile in fullOptJS).value
+    val output = LinkerOutput(MemOutputFile())
+    Await.result(
+      linker.link(ir, moduleInitializers, output, sbtLogger2ToolsLogger(log)),
+      Duration.Inf)
+  }.tag((usesScalaJSLinkerTag in Compile 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 in Compile).value
+  concurrentFakeFullOptJS.value
+}

sbt-plugin/src/sbt-test/linker-tags/concurrent-linker-use/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.2.8

sbt-plugin/src/sbt-test/linker-tags/concurrent-linker-use/project/build.sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % sys.props("plugin.version"))

sbt-plugin/src/sbt-test/linker-tags/concurrent-linker-use/test

@@ -0,0 +1 @@
+> concurrentUseOfLinkerTest