Merge pull request #96 from sjrd/finish-top-level-exports

Implement support for the remaining top-level exports.

Author: tanishiking

Diff for: test-suite/src/main/scala/testsuite/core/JSExportTopLevelTest.scala

@@ -0,0 +1,35 @@
+package testsuite.core
+
+import scala.scalajs.js
+import scala.scalajs.js.annotation._
+
+object JSExportTopLevelTest {
+  def main(): Unit = {
+    /* The main() function of this test does nothing.
+     * The real test happens after loading the module from TestSuites.scala.
+     */
+    ()
+  }
+
+  @JSExportTopLevel("immutableField")
+  val immutableField: String = "my immutable field value"
+
+  @JSExportTopLevel("mutableField")
+  var mutableField: Int = 42
+
+  @JSExportTopLevel("simpleFunction")
+  def simpleFunction(x: Int): Int =
+    x * x
+
+  @JSExportTopLevel("functionWithRest")
+  def functionWithRest(x: Int, rest: Int*): Int =
+    x * rest.sum
+
+  @JSExportTopLevel("SimpleClass")
+  class SimpleClass(val foo: Int) extends js.Object
+
+  @JSExportTopLevel("SimpleObject")
+  object SimpleObject extends js.Object {
+    val bar: String = "the bar field"
+  }
+}

Diff for: tests/src/test/scala/tests/CoreTests.scala

@@ -75,9 +75,10 @@ class CoreTests extends munit.FunSuite {
     for {
       irFiles <- irFilesFuture
       linkerResult <- linker.link(irFiles, moduleInitializers, output, logger)
-      runResult <- js.`import`[js.Any](s"$outputDirRelToMyJSFile/main.mjs").toFuture
+      moduleExports <- js.`import`[js.Dynamic](s"$outputDirRelToMyJSFile/main.mjs").toFuture
     } yield {
-      ()
+      for (postLoadTests <- suite.postLoadTests)
+        postLoadTests(moduleExports)
     }
   }
 }

Diff for: tests/src/test/scala/tests/TestSuites.scala

@@ -1,7 +1,14 @@
 package tests
 
+import scala.scalajs.js
+
 object TestSuites {
-  case class TestSuite(className: String, methodName: String = "main")
+  case class TestSuite(
+      className: String,
+      methodName: String = "main",
+      postLoadTests: Option[js.Dynamic => Unit] = None
+  )
+
   val suites = List(
     TestSuite("testsuite.core.Simple"),
     TestSuite("testsuite.core.Add"),
@@ -38,6 +45,21 @@ object TestSuites {
     TestSuite("testsuite.core.MatchTest"),
     TestSuite("testsuite.core.WrapUnwrapThrowableTest"),
     TestSuite("testsuite.core.StringEncodingTest"),
-    TestSuite("testsuite.core.ReflectiveCallTest")
+    TestSuite("testsuite.core.ReflectiveCallTest"),
+    TestSuite(
+      "testsuite.core.JSExportTopLevelTest",
+      postLoadTests = Some({ moduleExports =>
+        import munit.Assertions.assert
+
+        assert((moduleExports.immutableField: Any) == "my immutable field value")
+        assert((moduleExports.mutableField: Any) == 42)
+        assert((moduleExports.simpleFunction(5): Any) == 25)
+        assert((moduleExports.functionWithRest(3, 5, 6, 7): Any) == 54)
+        assert((moduleExports.SimpleObject.bar: Any) == "the bar field")
+
+        val obj = js.Dynamic.newInstance(moduleExports.SimpleClass)(456)
+        assert((obj.foo: Any) == 456)
+      })
+    )
   )
 }

Diff for: wasm/src/main/scala/WebAssemblyLinkerBackend.scala

@@ -101,7 +101,11 @@ final class WebAssemblyLinkerBackend(
     val classesWithStaticInit =
       sortedClasses.filter(_.hasStaticInitializer).map(_.className)
 
-    context.complete(onlyModule.initializers.toList, classesWithStaticInit)
+    context.complete(
+      onlyModule.initializers.toList,
+      classesWithStaticInit,
+      onlyModule.topLevelExports
+    )
 
     val outputImpl = OutputDirectoryImpl.fromOutputDirectory(output)
 

Diff for: wasm/src/main/scala/ir2wasm/LoaderContent.scala

@@ -112,6 +112,7 @@ const scalaJSHelpers = {
   closureThis: (f, data) => function(...args) { return f(data, this, ...args); },
   closureRest: (f, data, n) => ((...args) => f(data, ...args.slice(0, n), args.slice(n))),
   closureThisRest: (f, data, n) => function(...args) { return f(data, this, ...args.slice(0, n), args.slice(n)); },
+  closureRestNoData: (f, n) => ((...args) => f(...args.slice(0, n), args.slice(n))),
 
   // Strings
   emptyString: () => "",

Diff for: wasm/src/main/scala/ir2wasm/WasmBuilder.scala

@@ -143,8 +143,8 @@ class WasmBuilder {
       topLevelExport: LinkedTopLevelExport
   )(implicit ctx: WasmContext): Unit = {
     topLevelExport.tree match {
-      case d: IRTrees.TopLevelJSClassExportDef => ???
-      case d: IRTrees.TopLevelModuleExportDef  => ???
+      case d: IRTrees.TopLevelJSClassExportDef => genDelayedTopLevelExport(d.exportName)
+      case d: IRTrees.TopLevelModuleExportDef  => genDelayedTopLevelExport(d.exportName)
       case d: IRTrees.TopLevelMethodExportDef  => transformTopLevelMethodExportDef(d)
       case d: IRTrees.TopLevelFieldExportDef   => transformTopLevelFieldExportDef(d)
     }
@@ -928,25 +928,26 @@ class WasmBuilder {
     val method = exportDef.methodDef
     val exportedName = exportDef.topLevelExportName
 
-    if (method.restParam.isDefined) {
-      throw new UnsupportedOperationException(
-        s"Top-level export with ...rest param is unsupported at ${method.pos}: $method"
-      )
-    }
-
     implicit val fctx = WasmFunctionContext(
       enclosingClassName = None,
       Names.WasmFunctionName.forExport(exportedName),
       receiverTyp = None,
-      method.args,
+      method.args ::: method.restParam.toList,
       IRTypes.AnyType
     )
 
     WasmExpressionBuilder.generateIRBody(method.body, IRTypes.AnyType)
 
     val func = fctx.buildAndAddToContext()
 
-    ctx.addExport(WasmExport.Function(exportedName, func.name))
+    if (method.restParam.isEmpty) {
+      ctx.addExport(WasmExport.Function(exportedName, func.name))
+    } else {
+      /* We cannot directly export the function. We will create a closure
+       * wrapper in the start function and export that instead.
+       */
+      genDelayedTopLevelExport(exportedName)
+    }
   }
 
   private def transformTopLevelFieldExportDef(
@@ -959,6 +960,32 @@ class WasmBuilder {
     ctx.addExport(exprt)
   }
 
+  /** Generates a delayed top-level export global, to be initialized in the `start` function.
+    *
+    * Some top-level exports need to be initialized by run-time code because they need to call
+    * initializing functions:
+    *
+    *   - methods with a `...rest` need to be initialized with the `closureRestNoArg` helper.
+    *   - JS classes need to be initialized with their `loadJSClass` helper.
+    *   - JS modules need to be initialized with their `loadModule` helper.
+    *
+    * For all of those, we use `genDelayedTopLevelExport` to generate a Wasm global initialized with
+    * `null` and to export it. We actually initialize the global in the `start` function (see
+    * `genStartFunction()` in `WasmContext`).
+    */
+  private def genDelayedTopLevelExport(exportedName: String)(implicit ctx: WasmContext): Unit = {
+    val globalName = WasmGlobalName.forTopLevelExport(exportedName)
+    ctx.addGlobal(
+      WasmGlobal(
+        globalName,
+        WasmRefType.anyref,
+        WasmExpr(List(REF_NULL(WasmHeapType.None))),
+        isMutable = true
+      )
+    )
+    ctx.addExport(WasmExport.Global(exportedName, globalName))
+  }
+
   private def genFunction(
       clazz: LinkedClass,
       method: IRTrees.MethodDef

Diff for: wasm/src/main/scala/wasm4s/Names.scala

@@ -68,6 +68,9 @@ object Names {
     def forStaticField(fieldName: IRNames.FieldName): WasmGlobalName =
       new WasmGlobalName(s"static.${fieldName.nameString}")
 
+    def forTopLevelExport(exportName: String): WasmGlobalName =
+      new WasmGlobalName(s"export.$exportName")
+
     def forJSPrivateField(fieldName: IRNames.FieldName): WasmGlobalName =
       new WasmGlobalName(s"jspfield.${fieldName.nameString}")
 
@@ -169,6 +172,7 @@ object Names {
     val closureThis = helper("closureThis")
     val closureRest = helper("closureRest")
     val closureThisRest = helper("closureThisRest")
+    val closureRestNoData = helper("closureRestNoData")
 
     val emptyString = helper("emptyString")
     val stringLength = helper("stringLength")

Diff for: wasm/src/main/scala/wasm4s/WasmContext.scala

@@ -19,6 +19,8 @@ import wasm.ir2wasm.WasmExpressionBuilder
 
 import org.scalajs.linker.interface.ModuleInitializer
 import org.scalajs.linker.interface.unstable.ModuleInitializerImpl
+import org.scalajs.linker.standard.LinkedTopLevelExport
+
 import java.nio.charset.StandardCharsets
 
 trait ReadOnlyWasmContext {
@@ -403,6 +405,11 @@ class WasmContext(val module: WasmModule) extends TypeDefinableWasmContext {
     List(WasmRefType.func, anyref, WasmInt32),
     List(WasmRefType.any)
   )
+  addHelperImport(
+    WasmFunctionName.closureRestNoData,
+    List(WasmRefType.func, WasmInt32),
+    List(WasmRefType.any)
+  )
 
   addHelperImport(WasmFunctionName.emptyString, List(), List(WasmRefType.any))
   addHelperImport(WasmFunctionName.stringLength, List(WasmRefType.any), List(WasmInt32))
@@ -536,7 +543,8 @@ class WasmContext(val module: WasmModule) extends TypeDefinableWasmContext {
 
   def complete(
       moduleInitializers: List[ModuleInitializer.Initializer],
-      classesWithStaticInit: List[IRNames.ClassName]
+      classesWithStaticInit: List[IRNames.ClassName],
+      topLevelExportDefs: List[LinkedTopLevelExport]
   ): Unit = {
     /* Before generating the string globals in `genStartFunction()`, make sure
      * to allocate the ones that will be required by the module initializers.
@@ -566,13 +574,14 @@ class WasmContext(val module: WasmModule) extends TypeDefinableWasmContext {
       )
     )
 
-    genStartFunction(moduleInitializers, classesWithStaticInit)
+    genStartFunction(moduleInitializers, classesWithStaticInit, topLevelExportDefs)
     genDeclarativeElements()
   }
 
   private def genStartFunction(
       moduleInitializers: List[ModuleInitializer.Initializer],
-      classesWithStaticInit: List[IRNames.ClassName]
+      classesWithStaticInit: List[IRNames.ClassName],
+      topLevelExportDefs: List[LinkedTopLevelExport]
   ): Unit = {
     import WasmInstr._
     import WasmTypeName._
@@ -638,6 +647,30 @@ class WasmContext(val module: WasmModule) extends TypeDefinableWasmContext {
       instrs += WasmInstr.CALL(funcName)
     }
 
+    // Initialize the top-level exports that require it
+
+    for (tle <- topLevelExportDefs) {
+      tle.tree match {
+        case IRTrees.TopLevelJSClassExportDef(_, exportName) =>
+          instrs += CALL(WasmFunctionName.loadJSClass(tle.owningClass))
+          instrs += GLOBAL_SET(WasmGlobalName.forTopLevelExport(tle.exportName))
+        case IRTrees.TopLevelModuleExportDef(_, exportName) =>
+          instrs += CALL(WasmFunctionName.loadModule(tle.owningClass))
+          instrs += GLOBAL_SET(WasmGlobalName.forTopLevelExport(tle.exportName))
+        case IRTrees.TopLevelMethodExportDef(_, methodDef) =>
+          // We only need initialization if there is a restParam
+          if (methodDef.restParam.isDefined) {
+            instrs += refFuncWithDeclaration(WasmFunctionName.forExport(tle.exportName))
+            instrs += I32_CONST(methodDef.args.size)
+            instrs += CALL(WasmFunctionName.closureRestNoData)
+            instrs += GLOBAL_SET(WasmGlobalName.forTopLevelExport(tle.exportName))
+          }
+        case IRTrees.TopLevelFieldExportDef(_, _, _) =>
+          // Nothing to do
+          ()
+      }
+    }
+
     // Emit the module initializers
 
     moduleInitializers.foreach { init =>