Use the legacy try instruction to implement TryCatch.

This will allow to use the `JSTag` behavior for catching JS
exceptions, while waiting for Node.js to catch up with V8 12.5.

Luckily, we only need that for `TryCatch` and not for `TryFinally`.

Author: sjrd

wasm/src/main/scala/converters/WasmTextWriter.scala

@@ -318,8 +318,8 @@ class WasmTextWriter {
 
   private def writeInstr(instr: WasmInstr)(implicit b: WatBuilder): Unit = {
     instr match {
-      case END | ELSE => b.deindent()
-      case _          => ()
+      case END | ELSE | _: CATCH | CATCH_ALL => b.deindent()
+      case _                                 => ()
     }
     b.newLine()
     b.appendElement(instr.mnemonic)
@@ -333,8 +333,8 @@ class WasmTextWriter {
     writeInstrImmediates(instr)
 
     instr match {
-      case _: StructuredLabeledInstr | ELSE => b.indent()
-      case _                                => ()
+      case _: StructuredLabeledInstr | ELSE | _: CATCH | CATCH_ALL => b.indent()
+      case _                                                       => ()
     }
   }
 

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

@@ -21,6 +21,23 @@ import _root_.wasm4s.Defaults
 import EmbeddedConstants._
 
 object WasmExpressionBuilder {
+
+  /** Whether to use the legacy `try` instruction to implement `TryCatch`.
+    *
+    * Support for catching JS exceptions was only added to `try_table` in V8 12.5 from April 2024.
+    * While waiting for Node.js to catch up with V8, we use `try` to implement our `TryCatch`.
+    *
+    * We use this "fixed configuration option" to keep the code that implements `TryCatch` using
+    * `try_table` in the codebase, as code that is actually compiled, so that refactorings apply to
+    * it as well. It also makes it easier to manually experiment with the new `try_table` encoding,
+    * which will become available in Chrome v125.
+    *
+    * Note that we use `try_table` regardless to implement `TryFinally`. Its `catch_all_ref` handler
+    * is perfectly happy to catch and rethrow JavaScript exception in Node.js 22. Duplicating that
+    * implementation for `try` would be a nightmare, given how complex it is already.
+    */
+  private final val UseLegacyExceptionsForTryCatch = true
+
   def generateIRBody(tree: IRTrees.Tree, resultType: IRTypes.Type)(implicit
       ctx: TypeDefinableWasmContext,
       fctx: WasmFunctionContext
@@ -1690,26 +1707,37 @@ private class WasmExpressionBuilder private (
   private def genTryCatch(t: IRTrees.TryCatch): IRTypes.Type = {
     val resultType = TypeTransformer.transformResultType(t.tpe)(ctx)
 
-    fctx.block(resultType) { doneLabel =>
-      fctx.block(Types.WasmRefType.anyref) { catchLabel =>
-        /* We used to have `resultType` as result of the try_table, wich 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
-         * enclosing block) and the `br` *inside* the `try_table` works.
-         */
-        fctx.tryTable(Types.WasmRefType.anyref)(
-          List(CatchClause.Catch(ctx.exceptionTagName, catchLabel))
-        ) {
-          genTree(t.block, t.tpe)
-          instrs += BR(doneLabel)
-        }
-      } // end block $catch
+    if (UseLegacyExceptionsForTryCatch) {
+      instrs += TRY(fctx.sigToBlockType(WasmFunctionSignature(Nil, resultType)))
+      genTree(t.block, t.tpe)
+      instrs += CATCH(ctx.exceptionTagName)
       fctx.withNewLocal(t.errVar.name, Types.WasmRefType.anyref) { exceptionLocal =>
         instrs += LOCAL_SET(exceptionLocal)
         genTree(t.handler, t.tpe)
       }
-    } // end block $done
+      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
+           * `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
+           * enclosing block) and the `br` *inside* the `try_table` works.
+           */
+          fctx.tryTable(Types.WasmRefType.anyref)(
+            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 += LOCAL_SET(exceptionLocal)
+          genTree(t.handler, t.tpe)
+        }
+      } // end block $done
+    }
 
     if (t.tpe == IRTypes.NothingType)
       instrs += UNREACHABLE

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

@@ -259,6 +259,16 @@ object WasmInstr {
       extends WasmInstr("try_table", 0x1F)
       with StructuredLabeledInstr
 
+  // Legacy exception system
+  case class TRY(i: BlockType, label: Option[WasmLabelName] = None)
+      extends WasmBlockTypeLabeledInstr("try", 0x06, i)
+  case class CATCH(i: WasmTagName) extends WasmTagInstr("catch", 0x07, i)
+  case object CATCH_ALL extends WasmSimpleInstr("catch_all", 0x19)
+  // case class DELEGATE(i: WasmLabelName) extends WasmLabelInstr("delegate", 0x18, i)
+  case class RETHROW(i: WasmLabelName)
+      extends WasmLabelInstr("rethrow", 0x09, i)
+      with StackPolymorphicInstr
+
   // Parametric instructions
   // https://webassembly.github.io/spec/core/syntax/instructions.html#parametric-instructions
   case object DROP extends WasmSimpleInstr("drop", 0x1A)

wasm/src/main/scala/wasm4s/WasmFunctionContext.scala

@@ -388,7 +388,7 @@ class WasmFunctionContext private (
         while (nestingLevel >= 0 && iter.hasNext) {
           val deadCodeInstr = iter.next()
           deadCodeInstr match {
-            case END | ELSE if nestingLevel == 0 =>
+            case END | ELSE | _: CATCH | CATCH_ALL if nestingLevel == 0 =>
               /* We have reached the end of the original block of dead code.
                * Actually emit this END or ELSE and then drop `nestingLevel`
                * below 0 to end the dead code processing loop.