Cache ScalaJS linkers for incremental linking (#1761)

* Cache Scala.js linkers for incremental linking

* Use TrieMap instead of mutable.Map

* Avoid caching fullLinkJS linker to save memory

* Cache only one linker per target path

* Use `withClosureCompiler` instead of `withClosureCompilerIfAvailable`

* Avoid redundant `withOptimizer(true)`

* Use SoftReference instead of WeakReference

Co-authored-by: Sébastien Doeraene <sjrdoeraene@gmail.com>

Author: lolgab

bridges/scalajs-1/src/main/scala/bloop/scalajs/JsBridge.scala

@@ -2,9 +2,11 @@ package bloop.scalajs
 
 import java.nio.file.Path
 
+import scala.collection.concurrent.TrieMap
 import scala.concurrent.Await
 import scala.concurrent.ExecutionContext
 import scala.concurrent.duration.Duration
+import scala.ref.SoftReference
 
 import bloop.config.Config.JsConfig
 import bloop.config.Config.LinkerMode
@@ -51,6 +53,40 @@ object JsBridge {
       }
     override def trace(t: => Throwable): Unit = logger.trace(t)
   }
+  private object ScalaJSLinker {
+    private val cache = TrieMap.empty[Path, SoftReference[(JsConfig, Linker)]]
+    def reuseOrCreate(config: JsConfig, target: Path): Linker =
+      if (config.mode == LinkerMode.Release) createLinker(config)
+      else
+        cache.get(target) match {
+          case Some(SoftReference((`config`, linker))) => linker
+          case _ =>
+            val newLinker = createLinker(config)
+            cache.update(target, SoftReference((config, newLinker)))
+            newLinker
+        }
+    private def createLinker(config: JsConfig): Linker = {
+      val isFullLinkJS = config.mode == LinkerMode.Release
+      val semantics =
+        if (isFullLinkJS) Semantics.Defaults.optimized
+        else Semantics.Defaults
+      val scalaJSModuleKind = config.kind match {
+        case ModuleKindJS.NoModule => ScalaJSModuleKind.NoModule
+        case ModuleKindJS.CommonJSModule => ScalaJSModuleKind.CommonJSModule
+        case ModuleKindJS.ESModule => ScalaJSModuleKind.ESModule
+      }
+
+      val useClosure = isFullLinkJS && config.kind != ModuleKindJS.ESModule
+
+      val linkerConfig = StandardConfig()
+        .withClosureCompiler(useClosure)
+        .withSemantics(semantics)
+        .withModuleKind(scalaJSModuleKind)
+        .withSourceMap(config.emitSourceMaps)
+
+      StandardImpl.clearableLinker(linkerConfig)
+    }
+  }
 
   def link(
       config: JsConfig,
@@ -64,17 +100,7 @@ object JsBridge {
   ): Unit = {
     implicit val ec = executionContext
     implicit val logFilter: DebugFilter = DebugFilter.Link
-    val enableOptimizer = config.mode == LinkerMode.Release
-    val semantics = config.mode match {
-      case LinkerMode.Debug => Semantics.Defaults
-      case LinkerMode.Release => Semantics.Defaults.optimized
-    }
-
-    val moduleKind = config.kind match {
-      case ModuleKindJS.NoModule => ScalaJSModuleKind.NoModule
-      case ModuleKindJS.CommonJSModule => ScalaJSModuleKind.CommonJSModule
-      case ModuleKindJS.ESModule => ScalaJSModuleKind.ESModule
-    }
+    val linker = ScalaJSLinker.reuseOrCreate(config, target)
 
     val cache = StandardImpl.irFileCache().newCache
     val irContainersPairs = PathIRContainer.fromClasspath(classpath)
@@ -101,18 +127,10 @@ object JsBridge {
     }
 
     val output = LinkerOutput(PathOutputFile(target))
-    val jsConfig = StandardConfig()
-      .withOptimizer(enableOptimizer)
-      .withClosureCompilerIfAvailable(enableOptimizer)
-      .withSemantics(semantics)
-      .withModuleKind(moduleKind)
-      .withSourceMap(config.emitSourceMaps)
 
     val resultFuture = for {
       libraryIRs <- libraryIrsFuture
-      _ <- StandardImpl
-        .linker(jsConfig)
-        .link(libraryIRs, moduleInitializers, output, new Logger(logger))
+      _ <- linker.link(libraryIRs, moduleInitializers, output, new Logger(logger))
     } yield ()
 
     Await.result(resultFuture, Duration.Inf)