Load linker reflectively in the sbt plugin

gzm0 · gzm0 · commit e02fe17a369d · 2019-10-11T16:51:11.000+02:00
diff --git a/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/CacheBox.scala b/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/CacheBox.scala
@@ -0,0 +1,35 @@
+/*
+ * Scala.js (https://www.scala-js.org/)
+ *
+ * Copyright EPFL.
+ *
+ * Licensed under Apache License 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package org.scalajs.sbtplugin
+
+/** A CacheBox is support class to abuse an sbt setting as a cache.
+ *
+ *  A CacheBox is needed, once the cached result needs to depend on a task,
+ *  since then it cannot simply be made a setting anymore.
+ */
+private[sbtplugin] final class CacheBox[T] {
+  private[this] var value: T = _
+
+  def ensure(f: => T): T = synchronized {
+    if (value == null) {
+      value = f
+    }
+    value
+  }
+
+  def foreach(f: T => Unit): Unit = synchronized {
+    if (value != null) {
+      f(value)
+    }
+  }
+}
diff --git a/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/LinkerImpl.scala b/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/LinkerImpl.scala
@@ -0,0 +1,109 @@
+/*
+ * Scala.js (https://www.scala-js.org/)
+ *
+ * Copyright EPFL.
+ *
+ * Licensed under Apache License 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package org.scalajs.sbtplugin
+
+import scala.concurrent._
+
+import java.lang.reflect.{Method, Modifier}
+import java.nio.file.Path
+
+import org.scalajs.linker.interface._
+
+/** Abstract implementation of a linker as needed by the sbt plugin.
+ *
+ *  @note This trait does not guarantee full compatibility: Methods may be added
+ *      / removed in the future. Use [[LinkerImpl.Forwarding]] to override things
+ *      selectively in a compatible manner.
+ */
+trait LinkerImpl {
+  def clearableLinker(cfg: StandardConfig): ClearableLinker
+
+  def irFileCache(): IRFileCache
+
+  def irContainers(classpath: Seq[Path])(
+      implicit ec: ExecutionContext): Future[(Seq[IRContainer], Seq[Path])]
+
+  def outputFile(path: Path): LinkerOutput.File
+}
+
+object LinkerImpl {
+  /** Returns the default implementation.
+   *
+   *  It loads a StandardLinker via reflection.
+   */
+  def default(loader: ClassLoader): LinkerImpl = new Reflect(loader)
+
+  /** A [[LinkerImpl]] that forwards everything to `parent`.
+   *
+   *  This is useful if only parts of the linker implementation need to be
+   *  replaced. A subclass only overriding these can be created, ensuring easier
+   *  transition when methods get added.
+   */
+  class Forwarding(parent: LinkerImpl) extends LinkerImpl {
+    def clearableLinker(cfg: StandardConfig): ClearableLinker =
+      parent.clearableLinker(cfg)
+
+    def irFileCache(): IRFileCache =
+      parent.irFileCache()
+
+    def irContainers(classpath: Seq[Path])(
+        implicit ec: ExecutionContext): Future[(Seq[IRContainer], Seq[Path])] =
+      parent.irContainers(classpath)
+
+    def outputFile(path: Path): LinkerOutput.File =
+      parent.outputFile(path)
+  }
+
+  private final class Reflect(loader: ClassLoader) extends LinkerImpl {
+    private def loadMethod(clazz: String, method: String, result: Class[_], params: Class[_]*): Method = {
+      val m = Class.forName("org.scalajs.linker." + clazz, true, loader).getMethod(method, params: _*)
+      require(Modifier.isStatic(m.getModifiers()))
+      require(result.isAssignableFrom(m.getReturnType()))
+      m
+    }
+
+    private def invoke[T](method: Method, args: AnyRef*): T =
+      method.invoke(null, args: _*).asInstanceOf[T]
+
+    /* We load everything eagery to fail immediately, not only when the methods
+     * are invoked.
+     */
+    private val clearableLinkerMethod =
+      loadMethod("StandardImpl", "clearableLinker", classOf[ClearableLinker], classOf[StandardConfig])
+
+    private val irFileCacheMethod =
+      loadMethod("StandardImpl", "irFileCache", classOf[IRFileCache])
+
+    private val irContainersMethod = {
+      loadMethod("PathIRContainer", "fromClasspath", classOf[Future[_]],
+        classOf[Seq[Path]], classOf[ExecutionContext])
+    }
+
+    private val outputFileMethod =
+      loadMethod("PathOutputFile", "atomic", classOf[LinkerOutput.File], classOf[Path])
+
+    def clearableLinker(cfg: StandardConfig): ClearableLinker =
+      invoke(clearableLinkerMethod, cfg)
+
+    def irFileCache(): IRFileCache =
+      invoke(irFileCacheMethod)
+
+    def irContainers(classpath: Seq[Path])(
+        implicit ec: ExecutionContext): Future[(Seq[IRContainer], Seq[Path])] = {
+      invoke(irContainersMethod, classpath, ec)
+    }
+
+    def outputFile(path: Path): LinkerOutput.File =
+      invoke(outputFileMethod, path)
+  }
+}
diff --git a/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/ScalaJSPlugin.scala b/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/ScalaJSPlugin.scala
@@ -57,13 +57,17 @@ object ScalaJSPlugin extends AutoPlugin {
 
     // All our public-facing keys
 
-    val scalaJSIRCache = SettingKey[IRFileCache.Cache](
-        "scalaJSIRCache",
-        "Scala.js internal: Task to access a cache.", KeyRanks.Invisible)
+    val scalaJSIRCacheBox = SettingKey[CacheBox[IRFileCache.Cache]](
+        "scalaJSIRCacheBox",
+        "Scala.js internal: CacheBox for a cache.", KeyRanks.Invisible)
 
-    /** Persisted instance of the Scala.js linker.
+    val scalaJSGlobalIRCacheBox = SettingKey[CacheBox[IRFileCache]](
+        "scalaJSGlobalIRCacheBox",
+        "Scala.js internal: CacheBox for the global cache.", KeyRanks.Invisible)
+
+    /** Instance of the Scala.js linker.
      *
-     *  This setting must be scoped per project, configuration, and stage task
+     *  This task must be scoped per project, configuration, and stage task
      *  (`fastOptJS` or `fullOptJS`).
      *
      *  If a task uses the `link` method of the `ClearableLinker`, it must be
@@ -82,9 +86,19 @@ object ScalaJSPlugin extends AutoPlugin {
      *    }.tag(usesLinkerTag)
      *  }.value,
      *  }}}
+     *
+     *  Do not set this value. Instead, set [[scalaJSLinkerImpl]]. This will
+     *  automatically set up the correct caching behavior.
      */
-    val scalaJSLinker = SettingKey[ClearableLinker]("scalaJSLinker",
-        "Persisted instance of the Scala.js linker", KeyRanks.Invisible)
+    val scalaJSLinker = TaskKey[ClearableLinker]("scalaJSLinker",
+        "Access task for a Scala.js linker. Use this if you want to use the linker.",
+        KeyRanks.Invisible)
+
+    val scalaJSLinkerImpl = TaskKey[LinkerImpl]("scalaJSLinkerImpl",
+        "Factory for a Scala.js linker", KeyRanks.Invisible)
+
+    val scalaJSLinkerBox = SettingKey[CacheBox[ClearableLinker]]("scalaJSLinkerBox",
+        "CacheBox for a Scala.js linker", KeyRanks.Invisible)
 
     /** A tag to indicate that a task is using the value of [[scalaJSLinker]]
      *  and its `link` method.
@@ -172,9 +186,14 @@ object ScalaJSPlugin extends AutoPlugin {
   import autoImport._
 
   /** Logs the current statistics about the global IR cache. */
-  def logIRCacheStats(logger: Logger): Unit = {
-    import ScalaJSPluginInternal.globalIRCache
-    logger.debug("Global IR cache stats: " + globalIRCache.stats.logLine)
+  val irCacheStatsLogger: Def.Initialize[Logger => Unit] = Def.setting {
+    val globalIRCacheBox = scalaJSGlobalIRCacheBox.value
+
+    logger: Logger => {
+      globalIRCacheBox.foreach { globalIRCache =>
+        logger.debug("Global IR cache stats: " + globalIRCache.stats.logLine)
+      }
+    }
   }
 
   override def globalSettings: Seq[Setting[_]] = {
@@ -183,16 +202,21 @@ object ScalaJSPlugin extends AutoPlugin {
 
         scalaJSLinkerConfig := StandardConfig(),
 
+        scalaJSLinkerImpl := LinkerImpl.default(getClass().getClassLoader()),
+
+        scalaJSGlobalIRCacheBox := new CacheBox,
+
         jsEnv := new NodeJSEnv(),
 
         // Clear the IR cache stats every time a sequence of tasks ends
         onComplete := {
           val prev = onComplete.value
+          val globalIRCacheBox = scalaJSGlobalIRCacheBox.value
 
           { () =>
             prev()
             ScalaJSPluginInternal.closeAllTestAdapters()
-            ScalaJSPluginInternal.globalIRCache.clearStats()
+            globalIRCacheBox.foreach(_.clearStats())
           }
         },
 
diff --git a/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/ScalaJSPluginInternal.scala b/sbt-plugin/src/main/scala/org/scalajs/sbtplugin/ScalaJSPluginInternal.scala
@@ -28,7 +28,6 @@ import sbt.complete.DefaultParsers._
 
 import org.portablescala.sbtplatformdeps.PlatformDepsPlugin.autoImport._
 
-import org.scalajs.linker.{StandardImpl, PathIRContainer, PathOutputFile}
 import org.scalajs.linker.interface._
 import org.scalajs.linker.interface.unstable.IRFileImpl
 
@@ -48,10 +47,7 @@ import sjsonnew.BasicJsonProtocol.seqFormat
 private[sbtplugin] object ScalaJSPluginInternal {
 
   import ScalaJSPlugin.autoImport.{ModuleKind => _, _}
-  import ScalaJSPlugin.logIRCacheStats
-
-  /** The global Scala.js IR cache */
-  val globalIRCache: IRFileCache = StandardImpl.irFileCache()
+  import ScalaJSPlugin.irCacheStatsLogger
 
   @tailrec
   final private def registerResource[T <: AnyRef](
@@ -64,14 +60,6 @@ private[sbtplugin] object ScalaJSPluginInternal {
   private val allocatedIRCaches =
     new AtomicReference[List[IRFileCache.Cache]](Nil)
 
-  /** Allocates a new IR cache linked to the [[globalIRCache]].
-   *
-   *  The allocated IR cache will automatically be freed when the build is
-   *  unloaded.
-   */
-  private def newIRCache: IRFileCache.Cache =
-    registerResource(allocatedIRCaches, globalIRCache.newCache)
-
   private[sbtplugin] def freeAllIRCaches(): Unit =
     allocatedIRCaches.getAndSet(Nil).foreach(_.free())
 
@@ -126,8 +114,12 @@ private[sbtplugin] object ScalaJSPluginInternal {
   private def scalaJSStageSettings(stage: Stage,
       key: TaskKey[Attributed[File]]): Seq[Setting[_]] = Seq(
 
+      scalaJSLinkerBox in key := new CacheBox,
+
       scalaJSLinker in key := {
         val config = (scalaJSLinkerConfig in key).value
+        val box = (scalaJSLinkerBox in key).value
+        val linkerImpl = (scalaJSLinkerImpl in key).value
 
         if (config.moduleKind != scalaJSLinkerConfig.value.moduleKind) {
           val projectID = thisProject.value.id
@@ -140,13 +132,13 @@ private[sbtplugin] object ScalaJSPluginInternal {
               "Some things will go wrong.")
         }
 
-        StandardImpl.clearableLinker(config)
+        box.ensure(linkerImpl.clearableLinker(config))
       },
 
       // Have `clean` reset the state of the incremental linker
       clean in (This, Zero, This) := {
         val _ = (clean in (This, Zero, This)).value
-        (scalaJSLinker in key).value.clear()
+        (scalaJSLinkerBox in key).value.foreach(_.clear())
         ()
       },
 
@@ -179,8 +171,10 @@ private[sbtplugin] object ScalaJSPluginInternal {
         val moduleInitializers = scalaJSModuleInitializers.value
         val output = (artifactPath in key).value
         val linker = (scalaJSLinker in key).value
+        val linkerImpl = (scalaJSLinkerImpl in key).value
         val usesLinkerTag = (usesScalaJSLinkerTag in key).value
         val sourceMapFile = new File(output.getPath + ".map")
+        val logIRCacheStats = irCacheStatsLogger.value
 
         Def.task {
           val log = s.log
@@ -201,8 +195,8 @@ private[sbtplugin] object ScalaJSPluginInternal {
 
             def relURI(path: String) = new URI(null, null, path, null)
 
-            val out = LinkerOutput(PathOutputFile.atomic(output.toPath))
-              .withSourceMap(PathOutputFile.atomic(sourceMapFile.toPath))
+            val out = LinkerOutput(linkerImpl.outputFile(output.toPath))
+              .withSourceMap(linkerImpl.outputFile(sourceMapFile.toPath))
               .withSourceMapURI(relURI(sourceMapFile.getName))
               .withJSFileURI(relURI(output.getName))
 
@@ -243,10 +237,17 @@ private[sbtplugin] object ScalaJSPluginInternal {
       }
   ) ++ Seq(
       // Note: this cache is not cleared by the sbt's clean task.
-      scalaJSIRCache := newIRCache,
+      scalaJSIRCacheBox := new CacheBox,
 
       scalaJSIR := {
-        val cache = scalaJSIRCache.value
+        val linkerImpl = (scalaJSLinkerImpl in scalaJSIR).value
+
+        val globalIRCache = scalaJSGlobalIRCacheBox.value
+          .ensure(linkerImpl.irFileCache())
+
+        val cache = scalaJSIRCacheBox.value
+          .ensure(registerResource(allocatedIRCaches, globalIRCache.newCache))
+
         val classpath = Attributed.data(fullClasspath.value)
         val log = streams.value.log
         val tlog = sbtLogger2ToolsLogger(log)
@@ -256,7 +257,7 @@ private[sbtplugin] object ScalaJSPluginInternal {
             await(log) { eci =>
               implicit val ec = eci
               for {
-                (irContainers, paths) <- PathIRContainer.fromClasspath(classpath.map(_.toPath))
+                (irContainers, paths) <- linkerImpl.irContainers(classpath.map(_.toPath))
                 irFiles <- cache.cached(irContainers)
               } yield (irFiles, paths)
             }
@@ -311,7 +312,7 @@ private[sbtplugin] object ScalaJSPluginInternal {
           stdout.flush()
         }
 
-        logIRCacheStats(streams.value.log)
+        irCacheStatsLogger.value(streams.value.log)
       },
 
       artifactPath in fastOptJS :=
