Fix #75: Use WebAssembly.JSTag as our exception tag.

This allows us to actually catch exceptions thrown by JavaScript
code.

Author: sjrd

build.sbt

@@ -228,15 +228,14 @@ lazy val IgnoredTestNames: Set[String] = {
   Set(
     // reflective call: should be throw an exception when reflective proxy not found
     "org.scalajs.testsuite.compiler.WasPublicBeforeTyperTestScala2",
-    // Various run-time errors and JS exceptions
-    "org.scalajs.testsuite.compiler.InteroperabilityTest",
+    // javaLangClassGetNameRenamedThroughSemantics failed: org.junit.ComparisonFailure:
+    // expected:<[renamed.test.]Class> but was:<[org.scalajs.testsuite.compiler.ReflectionTest$RenamedTest]Class>
     "org.scalajs.testsuite.compiler.ReflectionTest",
-    "org.scalajs.testsuite.compiler.RegressionJSTest",
-    "org.scalajs.testsuite.jsinterop.FunctionTest",
-    "org.scalajs.testsuite.jsinterop.MiscInteropTest",
-    "org.scalajs.testsuite.jsinterop.NonNativeJSTypeTest",
-    "org.scalajs.testsuite.jsinterop.SpecialTest",
+    // wellKnownSymbolIterator/testToString failed: scala.scalajs.js.JavaScriptException: TypeError: Cannot convert a Symbol value to a string
     "org.scalajs.testsuite.jsinterop.SymbolTest",
+    // Cannot call wasmObject.toString() from JavaScript:
+    // boxValueClassesGivenToJSInteropMethod failed: scala.scalajs.js.JavaScriptException: TypeError: vc.toString is not a function
+    "org.scalajs.testsuite.compiler.InteroperabilityTest",
     // TypeError: WebAssembly objects are opaque
     "org.scalajs.testsuite.javalib.lang.SystemJSTest",
     // throwablesAreTrueErrors failed: org.junit.ComparisonFailure: expected:<[object [Error]]> but was:<[object [Object]]>

wasm/src/main/scala/ir2wasm/HelperFunctions.scala

@@ -690,6 +690,7 @@ object HelperFunctions {
         )
         instrs += CALL(WasmFunctionName.jsArrayPush)
         instrs += CALL(WasmFunctionName.jsNew)
+        instrs += EXTERN_CONVERT_ANY
         instrs += THROW(ctx.exceptionTagName)
       }
     ) { () =>

wasm/src/main/scala/ir2wasm/LoaderContent.scala

@@ -65,6 +65,9 @@ const linkingInfo = Object.freeze({
 });
 
 const scalaJSHelpers = {
+  // JSTag
+  JSTag: WebAssembly.JSTag,
+
   // BinaryOp.===
   is: Object.is,
 

wasm/src/main/scala/ir2wasm/WasmExpressionBuilder.scala

@@ -1712,27 +1712,29 @@ private class WasmExpressionBuilder private (
       genTree(t.block, t.tpe)
       instrs += CATCH(ctx.exceptionTagName)
       fctx.withNewLocal(t.errVar.name, Types.WasmRefType.anyref) { exceptionLocal =>
+        instrs += ANY_CONVERT_EXTERN
         instrs += LOCAL_SET(exceptionLocal)
         genTree(t.handler, t.tpe)
       }
       instrs += END
     } else {
       fctx.block(resultType) { doneLabel =>
-        fctx.block(Types.WasmRefType.anyref) { catchLabel =>
-          /* We used to have `resultType` as result of the try_table, wich the
+        fctx.block(Types.WasmRefType.externref) { catchLabel =>
+          /* We used to have `resultType` as result of the try_table, with the
            * `BR(doneLabel)` outside of the try_table. Unfortunately it seems
            * V8 cannot handle try_table with a result type that is `(ref ...)`.
-           * The current encoding with `anyref` as result type (to match the
+           * The current encoding with `externref` as result type (to match the
            * enclosing block) and the `br` *inside* the `try_table` works.
            */
-          fctx.tryTable(Types.WasmRefType.anyref)(
+          fctx.tryTable(Types.WasmRefType.externref)(
             List(CatchClause.Catch(ctx.exceptionTagName, catchLabel))
           ) {
             genTree(t.block, t.tpe)
             instrs += BR(doneLabel)
           }
         } // end block $catch
         fctx.withNewLocal(t.errVar.name, Types.WasmRefType.anyref) { exceptionLocal =>
+          instrs += ANY_CONVERT_EXTERN
           instrs += LOCAL_SET(exceptionLocal)
           genTree(t.handler, t.tpe)
         }
@@ -1790,6 +1792,7 @@ private class WasmExpressionBuilder private (
 
   private def genThrow(tree: IRTrees.Throw): IRTypes.Type = {
     genTree(tree.expr, IRTypes.AnyType)
+    instrs += EXTERN_CONVERT_ANY
     instrs += THROW(ctx.exceptionTagName)
 
     IRTypes.NothingType

wasm/src/main/scala/wasm4s/Instructions.scala

@@ -305,6 +305,9 @@ object WasmInstr {
     */
   case class REF_FUNC(i: WasmFunctionName) extends WasmFuncInstr("ref.func", 0xD2, i)
 
+  case object ANY_CONVERT_EXTERN extends WasmSimpleInstr("any.convert_extern", 0xFB1A)
+  case object EXTERN_CONVERT_ANY extends WasmSimpleInstr("extern.convert_any", 0xFB1B)
+
   case object REF_I31 extends WasmSimpleInstr("ref.i31", 0xFB1C)
   case object I31_GET_S extends WasmSimpleInstr("i31.get_s", 0xFB1D)
   case object I31_GET_U extends WasmSimpleInstr("i31.get_u", 0xFB1E)

wasm/src/main/scala/wasm4s/Types.scala

@@ -54,6 +54,9 @@ object Types {
     /** `(ref extern)`. */
     val extern: WasmRefType = apply(WasmHeapType.Extern)
 
+    /** `(ref null extern)`, i.e., `externref`. */
+    val externref: WasmRefType = nullable(WasmHeapType.Extern)
+
     /** `(ref null exn)`, i.e., `exnref`. */
     val exnref: WasmRefType = nullable(WasmHeapType.Exn)
 

wasm/src/main/scala/wasm4s/WasmContext.scala

@@ -335,9 +335,11 @@ class WasmContext(val module: WasmModule) extends TypeDefinableWasmContext {
   val exceptionTagName: WasmTagName = WasmTagName("exception")
 
   locally {
-    val exceptionSig = WasmFunctionSignature(List(anyref), Nil)
-    val exceptionFunType = addFunctionType(exceptionSig)
-    module.addTag(WasmTag(exceptionTagName, exceptionFunType))
+    val exceptionSig = WasmFunctionSignature(List(WasmRefType.externref), Nil)
+    val typ = WasmFunctionType(addFunctionType(exceptionSig), exceptionSig)
+    module.addImport(
+      WasmImport("__scalaJSHelpers", "JSTag", WasmImportDesc.Tag(exceptionTagName, typ))
+    )
   }
 
   private def addHelperImport(