Merge pull request #123 from sjrd/reorg-emitter

Reorganize the emitter to better match the JS backend.

Author: tanishiking

Diff for: wasm/src/main/scala/org/scalajs/linker/backend/WebAssemblyLinkerBackend.scala

@@ -5,8 +5,6 @@ import scala.concurrent.{ExecutionContext, Future}
 import java.nio.ByteBuffer
 import java.nio.charset.StandardCharsets
 
-import org.scalajs.ir.Names._
-
 import org.scalajs.logging.Logger
 
 import org.scalajs.linker._
@@ -16,8 +14,7 @@ import org.scalajs.linker.standard._
 
 import org.scalajs.linker.backend.webassembly._
 
-import org.scalajs.linker.backend.wasmemitter._
-import org.scalajs.linker.backend.wasmemitter.SpecialNames._
+import org.scalajs.linker.backend.wasmemitter.Emitter
 
 final class WebAssemblyLinkerBackend(
     linkerConfig: StandardConfig,
@@ -32,38 +29,18 @@ final class WebAssemblyLinkerBackend(
     "The WebAssembly backend does not support the optimizer yet."
   )
 
-  /* The symbol requirements of our back-end.
-   * The symbol requirements tell the LinkerFrontend that we need these
-   * symbols to always be reachable, even if no "user-land" IR requires them.
-   * They are roots for the reachability analysis, together with module
-   * initializers and top-level exports.
-   * If we don't do this, the linker frontend will dead-code eliminate our
-   * box classes.
-   */
-  val symbolRequirements: SymbolRequirement = {
-    val factory = SymbolRequirement.factory("wasm")
-
-    factory.multiple(
-      factory.instantiateClass(ClassClass, ClassCtor),
-      factory.instantiateClass(CharBoxClass, CharBoxCtor),
-      factory.instantiateClass(LongBoxClass, LongBoxCtor),
-
-      // See genIdentityHashCode in HelperFunctions
-      factory.callMethodStatically(BoxedDoubleClass, hashCodeMethodName),
-      factory.callMethodStatically(BoxedStringClass, hashCodeMethodName)
-    )
-  }
+  val loaderJSFileName = OutputPatternsImpl.jsFile(linkerConfig.outputPatterns, "__loader")
 
-  // Our injected IR files are handled by WebAssemblyStandardLinkerImpl instead
-  def injectedIRFiles: Seq[IRFile] = Nil
+  private val emitter: Emitter =
+    new Emitter(Emitter.Config(coreSpec, loaderJSFileName))
+
+  val symbolRequirements: SymbolRequirement = emitter.symbolRequirements
+
+  def injectedIRFiles: Seq[IRFile] = emitter.injectedIRFiles
 
   def emit(moduleSet: ModuleSet, output: OutputDirectory, logger: Logger)(implicit
       ec: ExecutionContext
   ): Future[Report] = {
-
-    val builder = new WasmBuilder(coreSpec)
-    implicit val context: WasmContext = new WasmContext()
-
     val onlyModule = moduleSet.modules match {
       case onlyModule :: Nil =>
         onlyModule
@@ -75,47 +52,15 @@ final class WebAssemblyLinkerBackend(
     }
     val moduleID = onlyModule.id.id
 
-    /* Sort by ancestor count so that superclasses always appear before
-     * subclasses, then tie-break by name for stability.
-     */
-    val sortedClasses = onlyModule.classDefs.sortWith { (a, b) =>
-      val cmp = Integer.compare(a.ancestors.size, b.ancestors.size)
-      if (cmp != 0) cmp < 0
-      else a.className.compareTo(b.className) < 0
-    }
-
-    // sortedClasses.foreach(cls => println(utils.LinkedClassPrinters.showLinkedClass(cls)))
-
-    Preprocessor.preprocess(sortedClasses, onlyModule.topLevelExports)(context)
-    HelperFunctions.genGlobalHelpers()
-    builder.genPrimitiveTypeDataGlobals()
-    sortedClasses.foreach { clazz =>
-      builder.transformClassDef(clazz)
-    }
-    // Array classes extend j.l.Object, so they must come after transformClassDef's
-    builder.genArrayClasses()
-    onlyModule.topLevelExports.foreach { tle =>
-      builder.transformTopLevelExport(tle)
-    }
-
-    val classesWithStaticInit =
-      sortedClasses.filter(_.hasStaticInitializer).map(_.className)
-
-    context.complete(
-      onlyModule.initializers.toList,
-      classesWithStaticInit,
-      onlyModule.topLevelExports
-    )
-
-    val wasmModule = context.moduleBuilder.build()
+    val emitterResult = emitter.emit(onlyModule, logger)
+    val wasmModule = emitterResult.wasmModule
 
     val outputImpl = OutputDirectoryImpl.fromOutputDirectory(output)
 
     val watFileName = s"$moduleID.wat"
     val wasmFileName = s"$moduleID.wasm"
     val sourceMapFileName = s"$wasmFileName.map"
     val jsFileName = OutputPatternsImpl.jsFile(linkerConfig.outputPatterns, moduleID)
-    val loaderJSFileName = OutputPatternsImpl.jsFile(linkerConfig.outputPatterns, "__loader")
 
     val filesToProduce0 = Set(
       wasmFileName,
@@ -168,12 +113,10 @@ final class WebAssemblyLinkerBackend(
     }
 
     def writeLoaderFile(): Future[Unit] =
-      outputImpl.writeFull(loaderJSFileName, ByteBuffer.wrap(LoaderContent.bytesContent))
+      outputImpl.writeFull(loaderJSFileName, ByteBuffer.wrap(emitterResult.loaderContent))
 
     def writeJSFile(): Future[Unit] = {
-      val jsFileOutput =
-        buildJSFileOutput(onlyModule, loaderJSFileName, wasmFileName, context.allImportedModules)
-      val jsFileOutputBytes = jsFileOutput.getBytes(StandardCharsets.UTF_8)
+      val jsFileOutputBytes = emitterResult.jsFileContent.getBytes(StandardCharsets.UTF_8)
       outputImpl.writeFull(jsFileName, ByteBuffer.wrap(jsFileOutputBytes))
     }
 
@@ -194,41 +137,4 @@ final class WebAssemblyLinkerBackend(
       new ReportImpl(List(reportModule))
     }
   }
-
-  private def buildJSFileOutput(
-      module: ModuleSet.Module,
-      loaderJSFileName: String,
-      wasmFileName: String,
-      importedModules: List[String]
-  ): String = {
-    val (moduleImports, importedModulesItems) = (for {
-      (moduleName, idx) <- importedModules.zipWithIndex
-    } yield {
-      val identName = s"imported$idx"
-      val escapedModuleName = "\"" + moduleName + "\""
-      val moduleImport = s"import * as $identName from $escapedModuleName"
-      val item = s"  $escapedModuleName: $identName,"
-      (moduleImport, item)
-    }).unzip
-
-    /* TODO This is not correct for exported *vars*, since they won't receive
-     * updates from mutations after loading.
-     */
-    val reExportStats = for {
-      exportName <- module.topLevelExports.map(_.exportName)
-    } yield {
-      s"export let $exportName = __exports.$exportName;"
-    }
-
-    s"""
-      |${moduleImports.mkString("\n")}
-      |
-      |import { load as __load } from './${loaderJSFileName}';
-      |const __exports = await __load('./${wasmFileName}', {
-      |${importedModulesItems.mkString("\n")}
-      |});
-      |
-      |${reExportStats.mkString("\n")}
-    """.stripMargin.trim() + "\n"
-  }
 }