semantifold 0.11.0 → 0.13.0

package/src/backends/java.js

@@ -391,9 +391,15 @@ function emitStatement(writer, statement, indent, path) {
     writer.synthetic(");\n", "error construction close", [statement.error], [`${path}/error`])
     return
   }
+  if (statement.kind == "RethrowStatement") {
+    writer.mapped("throw", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "throw spacing", [statement], [path])
+    writer.mapped(statement.binding, {mappingKind: "exact", node: statement.bindingNode, path: `${path}/bindingNode`, role: "name"})
+    writer.mapped(";", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
   if (statement.kind == "TryStatement") {
-    const caught = writer.errorForId(statement.catchType.declarationId)
-
     writer.mapped("try", {mappingKind: "anchor", node: statement, path})
     writer.synthetic(" ", "try spacing", [statement], [path])
     writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
@@ -401,18 +407,31 @@ function emitStatement(writer, statement, indent, path) {
     emitBlock(writer, statement.body, `${indent}  `, `${path}/body`)
     writer.synthetic(indent, "indentation", [statement], [path])
     writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
-    writer.synthetic(" ", "catch spacing", [statement], [path])
-    writer.mapped("catch", {mappingKind: "anchor", node: statement, path, role: "catch"})
-    writer.synthetic(" (", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped(writer.errorNameForId(statement.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: statement.catchType, path: `${path}/catchType`, role: "type"})
-    writer.synthetic(" ", "catch binding spacing", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
-    writer.synthetic(") ", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped("{", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
-    writer.synthetic("\n", "line break", [statement], [path])
-    emitBlock(writer, statement.catchBody, `${indent}  `, `${path}/catchBody`)
-    writer.synthetic(indent, "indentation", [statement], [path])
-    writer.mapped("}", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
+    for (const [index, handler] of statement.handlers.entries()) {
+      const handlerPath = `${path}/handlers/${index}`
+      const caught = writer.errorForId(handler.catchType.declarationId)
+
+      writer.synthetic(" ", "catch spacing", [handler], [handlerPath])
+      writer.mapped("catch", {mappingKind: "anchor", node: handler, path: handlerPath, role: "catch"})
+      writer.synthetic(" (", "catch binding scaffolding", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped(writer.errorNameForId(handler.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: handler.catchType, path: `${handlerPath}/catchType`, role: "type"})
+      writer.synthetic(" ", "catch binding spacing", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped(handler.catchBinding.name, {mappingKind: "exact", node: handler.catchBinding, path: `${handlerPath}/catchBinding`, role: "name"})
+      writer.synthetic(") ", "catch binding scaffolding", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped("{", {mappingKind: "anchor", node: handler.catchBody, path: `${handlerPath}/catchBody`})
+      writer.synthetic("\n", "line break", [handler], [handlerPath])
+      emitBlock(writer, handler.catchBody, `${indent}  `, `${handlerPath}/catchBody`)
+      writer.synthetic(indent, "indentation", [handler], [handlerPath])
+      writer.mapped("}", {mappingKind: "anchor", node: handler.catchBody, path: `${handlerPath}/catchBody`})
+    }
+    if (statement.finallyBody) {
+      writer.synthetic(" ", "finally spacing", [statement], [path])
+      writer.mapped("finally", {mappingKind: "anchor", node: statement, path, role: "finally"})
+      writer.synthetic(" {\n", "finally scaffolding", [statement], [path])
+      emitBlock(writer, statement.finallyBody, `${indent}  `, `${path}/finallyBody`)
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("}", {mappingKind: "anchor", node: statement.finallyBody, path: `${path}/finallyBody`})
+    }
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }

package/src/backends/javascript.js

@@ -427,10 +427,14 @@ function emitStatement(writer, statement, indent, path, canonicalizeZero) {
     writer.synthetic(")\n", "error construction close", [statement.error], [`${path}/error`])
     return
   }
+  if (statement.kind == "RethrowStatement") {
+    writer.mapped("throw", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "throw spacing", [statement], [path])
+    writer.mapped(statement.binding, {mappingKind: "exact", node: statement.bindingNode, path: `${path}/bindingNode`, role: "name"})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
   if (statement.kind == "TryStatement") {
-    const caught = writer.errorForId(statement.catchType.declarationId)
-    const targetName = writer.errorNameForId(statement.catchType.declarationId)
-
     writer.mapped("try", {mappingKind: "anchor", node: statement, path})
     writer.synthetic(" ", "try spacing", [statement], [path])
     writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
@@ -438,21 +442,15 @@ function emitStatement(writer, statement, indent, path, canonicalizeZero) {
     emitBlock(writer, statement.body, `${indent}  `, `${path}/body`, canonicalizeZero)
     writer.synthetic(indent, "indentation", [statement], [path])
     writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
-    writer.synthetic(" ", "catch spacing", [statement], [path])
-    writer.mapped("catch", {mappingKind: "anchor", node: statement, path, role: "catch"})
-    writer.synthetic(" (", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
-    writer.synthetic(") {\n", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.synthetic(`${indent}  if (!(`, "exact catch guard", [statement], [path])
-    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
-    writer.synthetic(" instanceof ", "exact catch guard", [statement], [path])
-    writer.mapped(targetName, {mappingKind: "exact", name: caught.name, node: statement.catchType, path: `${path}/catchType`, role: "type"})
-    writer.synthetic(`)) {\n${indent}    throw `, "unmatched error propagation", [statement], [path])
-    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
-    writer.synthetic(`\n${indent}  }\n`, "unmatched error propagation", [statement], [path])
-    emitBlock(writer, statement.catchBody, `${indent}  `, `${path}/catchBody`, canonicalizeZero)
-    writer.synthetic(indent, "indentation", [statement], [path])
-    writer.mapped("}", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
+    if (statement.handlers.length > 0) emitJavaScriptHandler(writer, statement, 0, indent, path, canonicalizeZero)
+    if (statement.finallyBody) {
+      writer.synthetic(" ", "finally spacing", [statement], [path])
+      writer.mapped("finally", {mappingKind: "anchor", node: statement, path, role: "finally"})
+      writer.synthetic(" {\n", "finally scaffolding", [statement], [path])
+      emitBlock(writer, statement.finallyBody, `${indent}  `, `${path}/finallyBody`, canonicalizeZero)
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("}", {mappingKind: "anchor", node: statement.finallyBody, path: `${path}/finallyBody`})
+    }
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }
@@ -505,6 +503,73 @@ function emitStatement(writer, statement, indent, path, canonicalizeZero) {
   writer.synthetic("\n", "line break", [statement], [path])
 }
 
+/**
+ * Emits one ordered JavaScript catch handler with its exact nominal guard.
+ *
+ * JavaScript has no sibling catch clauses, so handler k > 0 hangs off handler k - 1's
+ * unmatched rethrow inside a nested try. Each handler body sits outside its own guard,
+ * so a raise from one handler body escapes outward instead of being caught by a later
+ * sibling handler, exactly like native ordered multi-catch.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").TryStatement} statement - Semantic try statement.
+ * @param {number} index - Zero-based ordered handler index.
+ * @param {string} indent - Leading indentation for this catch clause.
+ * @param {string} path - Exact JSON Pointer for the owning try statement.
+ * @param {boolean} canonicalizeZero - Whether scalar output canonicalizes zero.
+ * @returns {void}
+ */
+function emitJavaScriptHandler(writer, statement, index, indent, path, canonicalizeZero) {
+  const handler = statement.handlers[index]
+  const handlerPath = `${path}/handlers/${index}`
+  const bodyIndent = `${indent}  `
+  const caught = writer.errorForId(handler.catchType.declarationId)
+  const targetName = writer.errorNameForId(handler.catchType.declarationId)
+
+  writer.synthetic(" ", "catch spacing", [statement], [path])
+  writer.mapped("catch", {mappingKind: "anchor", node: handler, path: handlerPath, role: "catch"})
+  writer.synthetic(" (", "catch binding scaffolding", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+  writer.mapped(handler.catchBinding.name, {mappingKind: "exact", node: handler.catchBinding, path: `${handlerPath}/catchBinding`, role: "name"})
+  writer.synthetic(") {\n", "catch binding scaffolding", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+  writer.synthetic(`${bodyIndent}if (!(`, "exact catch guard", [handler], [handlerPath])
+  writer.mapped(handler.catchBinding.name, {mappingKind: "exact", node: handler.catchBinding, path: `${handlerPath}/catchBinding`, role: "name"})
+  writer.synthetic(" instanceof ", "exact catch guard", [handler], [handlerPath])
+  writer.mapped(targetName, {mappingKind: "exact", name: caught.name, node: handler.catchType, path: `${handlerPath}/catchType`, role: "type"})
+  writer.synthetic(")) {\n", "exact catch guard", [handler], [handlerPath])
+  if (index + 1 < statement.handlers.length) {
+    emitJavaScriptDispatch(writer, statement, index, indent, path, canonicalizeZero)
+    writer.synthetic(`${bodyIndent}} else {\n`, "matched error handling", [handler], [handlerPath])
+    emitBlock(writer, handler.catchBody, `${bodyIndent}  `, `${handlerPath}/catchBody`, canonicalizeZero)
+    writer.synthetic(`${bodyIndent}}\n`, "matched error handling close", [handler], [handlerPath])
+  } else {
+    writer.synthetic(`${bodyIndent}  throw `, "unmatched error propagation", [handler], [handlerPath])
+    writer.mapped(handler.catchBinding.name, {mappingKind: "exact", node: handler.catchBinding, path: `${handlerPath}/catchBinding`, role: "name"})
+    writer.synthetic(`\n${bodyIndent}}\n`, "unmatched error propagation", [handler], [handlerPath])
+    emitBlock(writer, handler.catchBody, bodyIndent, `${handlerPath}/catchBody`, canonicalizeZero)
+  }
+  writer.synthetic(indent, "indentation", [handler], [handlerPath])
+  writer.mapped("}", {mappingKind: "anchor", node: handler.catchBody, path: `${handlerPath}/catchBody`})
+}
+
+/**
+ * Emits the nested re-dispatch of one unmatched caught value to the remaining ordered handlers.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").TryStatement} statement - Semantic try statement.
+ * @param {number} index - Index of the handler whose value is re-dispatched.
+ * @param {string} indent - Leading indentation for this dispatch try.
+ * @param {string} path - Exact JSON Pointer for the owning try statement.
+ * @param {boolean} canonicalizeZero - Whether scalar output canonicalizes zero.
+ * @returns {void}
+ */
+function emitJavaScriptDispatch(writer, statement, index, indent, path, canonicalizeZero) {
+  writer.synthetic(`${indent}  try {\n`, "ordered handler dispatch", [statement], [path])
+  writer.synthetic(`${indent}    throw `, "ordered handler dispatch", [statement], [path])
+  writer.mapped(statement.handlers[index].catchBinding.name, {
+    mappingKind: "exact", node: statement.handlers[index].catchBinding, path: `${path}/handlers/${index}/catchBinding`, role: "name"
+  })
+  writer.synthetic(`\n${indent}  }`, "ordered handler dispatch", [statement], [path])
+  emitJavaScriptHandler(writer, statement, index + 1, `${indent}  `, path, canonicalizeZero)
+}
+
 /**
  * Emits one JavaScript local statement and its JSDoc type carrier.
  * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.

package/src/backends/ordered-expressions.js

@@ -5,7 +5,8 @@ import {unsupportedCapability} from "../diagnostic.js"
 
 /** @typedef {import("../semantic/types.js").Expression} Expression */
 /** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
-/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} PlannedValue */
+/** @typedef {Scalar | "void"} PlannedType */
+/** @typedef {{expression: Expression, path: string, type: PlannedType, name?: string}} PlannedValue */
 /** @typedef {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */
 /** @typedef {Array<string | number | boolean | Signature>} Signature */
 
@@ -20,7 +21,7 @@ export class OrderedExpressionPlanner {
     this.language = language
     this.functions = new Map(module.functions.map((declaration) => [
       declaration.name,
-      scalarName(declaration.returnType, language, declaration.location)
+      returnName(declaration.returnType, language, declaration.location)
     ]))
     this.nextTemporary = 1
   }
@@ -29,7 +30,7 @@ export class OrderedExpressionPlanner {
    * Resolves an expression type from the validated lexical environment.
    * @param {Expression} expression - Semantic expression.
    * @param {Map<string, Scalar>} bindings - Lexical scalar types.
-   * @returns {Scalar} Exact semantic result type.
+   * @returns {PlannedType} Exact semantic result type.
    */
   type(expression, bindings) {
     if (expression.kind == "IntegerLiteral") return "integer"
@@ -76,12 +77,31 @@ export class OrderedExpressionPlanner {
       }
       operands.push(this.plan(expression.right, `${path}/right`, bindings, steps))
     }
+    if (result.type == "void") throw new Error("Void call reached native value planning.")
     const planned = {...result, name: this.allocate(expression)}
 
     steps.push({operands, result: planned})
     return planned
   }
 
+  /**
+   * Plans the arguments of one terminal void call without inventing a void temporary.
+   * @param {Expression} expression - Terminal expression occurrence.
+   * @param {string} path - Occurrence path.
+   * @param {Map<string, Scalar>} bindings - Visible scalar bindings.
+   * @param {PlannedStep[]} steps - Ordered enclosing prelude.
+   * @returns {PlannedStep} Terminal direct-call step.
+   */
+  terminal(expression, path, bindings, steps) {
+    if (expression.kind != "CallExpression" || this.type(expression, bindings) != "void") {
+      throw new Error("Non-void expression reached native terminal-call planning.")
+    }
+    const result = {expression, path, type: /** @type {const} */ ("void")}
+    const operands = expression.arguments.map((argument, index) => this.plan(argument, `${path}/arguments/${index}`, bindings, steps))
+
+    return {operands, result}
+  }
+
   /**
    * Allocates one bounded deterministic occurrence name.
    * @param {Expression} expression - Related expression.
@@ -108,9 +128,9 @@ export function statementSignature(statement) {
       statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? statement.expression :
         statement.kind == "ReturnStatement" ? statement.expression : undefined
 
-  if (!expression) throw new TypeError("Bare return reached native statement signature planning.")
+  if (!expression && statement.kind != "ReturnStatement") throw new TypeError("Bare return reached native statement signature planning.")
 
-  return createHash("sha256").update(JSON.stringify([consumer, expressionSignature(expression)])).digest("hex")
+  return createHash("sha256").update(JSON.stringify([consumer, expression ? expressionSignature(expression) : null])).digest("hex")
 }
 
 /**
@@ -128,7 +148,7 @@ function expressionSignature(expression) {
   return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)]
 }
 
-/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+/** @typedef {{id: string, steps: PlannedStep[], value?: PlannedValue, terminal?: PlannedStep}} StatementPlan */
 /**
  * Plans every occurrence before constructing a writer or exposing either artifact.
  * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
@@ -159,12 +179,13 @@ export function planNativeModule(module, language = "c") {
             statement.kind == "ReturnStatement" ? statement.expression : undefined
       /** @type {PlannedStep[]} */
       const steps = []
-
-      if (!expression) throw new TypeError("Bare return reached native expression planning.")
-      const value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)
+      /** @type {StatementPlan} */
+      const plan = {id: String(plans.size + 1).padStart(6, "0"), steps}
 
       if (plans.size >= 999999) unsupportedCapability(language, "ordered statement limit", statement.location)
-      plans.set(statementPath, {id: String(plans.size + 1).padStart(6, "0"), steps, value})
+      if (statement.kind == "ExpressionStatement") plan.terminal = planner.terminal(statement.expression, `${statementPath}/${field}`, bindings, steps)
+      else if (expression) plan.value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)
+      plans.set(statementPath, plan)
       if (statement.kind == "LocalDeclaration") bindings.set(statement.name, scalarName(statement.type, language, statement.location))
       if (statement.kind == "IfStatement") {
         visit(statement.consequent, `${statementPath}/consequent`, bindings)
@@ -193,3 +214,18 @@ function scalarName(type, language, location) {
 
   return type.name
 }
+
+/**
+ * Narrows a validated function return, admitting the non-value `void` result.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {"c" | "cpp"} language - Diagnostic language.
+ * @param {import("../semantic/types.js").SourceLocation} location - Owning location.
+ * @returns {PlannedType} Scalar or void name.
+ */
+function returnName(type, language, location) {
+  if (type.kind != "TypeReference") {
+    return unsupportedCapability(language, "collection type reached native scalar planning", location)
+  }
+
+  return type.name
+}

package/src/backends/php.js

@@ -489,9 +489,15 @@ function emitStatement(writer, statement, indent, path) {
     writer.synthetic(");\n", "error construction close", [statement.error], [`${path}/error`])
     return
   }
+  if (statement.kind == "RethrowStatement") {
+    writer.mapped("throw", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "throw spacing", [statement], [path])
+    writer.mapped(`$${statement.binding}`, {mappingKind: "exact", node: statement.bindingNode, path: `${path}/bindingNode`, role: "name"})
+    writer.mapped(";", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
   if (statement.kind == "TryStatement") {
-    const caught = writer.errorForId(statement.catchType.declarationId)
-
     writer.mapped("try", {mappingKind: "anchor", node: statement, path})
     writer.synthetic(" ", "try spacing", [statement], [path])
     writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
@@ -499,18 +505,31 @@ function emitStatement(writer, statement, indent, path) {
     emitBlock(writer, statement.body, `${indent}    `, `${path}/body`)
     writer.synthetic(indent, "indentation", [statement], [path])
     writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
-    writer.synthetic(" ", "catch spacing", [statement], [path])
-    writer.mapped("catch", {mappingKind: "anchor", node: statement, path, role: "catch"})
-    writer.synthetic(" (", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped(writer.errorNameForId(statement.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: statement.catchType, path: `${path}/catchType`, role: "type"})
-    writer.synthetic(" ", "catch binding spacing", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped(`$${statement.catchBinding.name}`, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
-    writer.synthetic(") ", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped("{", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
-    writer.synthetic("\n", "line break", [statement], [path])
-    emitBlock(writer, statement.catchBody, `${indent}    `, `${path}/catchBody`)
-    writer.synthetic(indent, "indentation", [statement], [path])
-    writer.mapped("}", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
+    for (const [index, handler] of statement.handlers.entries()) {
+      const handlerPath = `${path}/handlers/${index}`
+      const caught = writer.errorForId(handler.catchType.declarationId)
+
+      writer.synthetic(" ", "catch spacing", [handler], [handlerPath])
+      writer.mapped("catch", {mappingKind: "anchor", node: handler, path: handlerPath, role: "catch"})
+      writer.synthetic(" (", "catch binding scaffolding", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped(writer.errorNameForId(handler.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: handler.catchType, path: `${handlerPath}/catchType`, role: "type"})
+      writer.synthetic(" ", "catch binding spacing", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped(`$${handler.catchBinding.name}`, {mappingKind: "exact", node: handler.catchBinding, path: `${handlerPath}/catchBinding`, role: "name"})
+      writer.synthetic(") ", "catch binding scaffolding", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped("{", {mappingKind: "anchor", node: handler.catchBody, path: `${handlerPath}/catchBody`})
+      writer.synthetic("\n", "line break", [handler], [handlerPath])
+      emitBlock(writer, handler.catchBody, `${indent}    `, `${handlerPath}/catchBody`)
+      writer.synthetic(indent, "indentation", [handler], [handlerPath])
+      writer.mapped("}", {mappingKind: "anchor", node: handler.catchBody, path: `${handlerPath}/catchBody`})
+    }
+    if (statement.finallyBody) {
+      writer.synthetic(" ", "finally spacing", [statement], [path])
+      writer.mapped("finally", {mappingKind: "anchor", node: statement, path, role: "finally"})
+      writer.synthetic(" {\n", "finally scaffolding", [statement], [path])
+      emitBlock(writer, statement.finallyBody, `${indent}    `, `${path}/finallyBody`)
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("}", {mappingKind: "anchor", node: statement.finallyBody, path: `${path}/finallyBody`})
+    }
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }

package/src/backends/ruby.js

@@ -364,22 +364,46 @@ function emitStatement(writer, statement, indent, path) {
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }
+  if (statement.kind == "RethrowStatement") {
+    writer.mapped("raise", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "raise spacing", [statement], [path])
+    writer.mapped(statement.binding, {mappingKind: "exact", node: statement.bindingNode, path: `${path}/bindingNode`, role: "name"})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
   if (statement.kind == "TryStatement") {
-    const caught = writer.errorForId(statement.catchType.declarationId)
-
     writer.mapped("begin", {mappingKind: "anchor", node: statement, path})
     writer.synthetic("\n", "line break", [statement], [path])
     emitBlock(writer, statement.body, `${indent}  `, `${path}/body`)
-    writer.synthetic(indent, "indentation", [statement], [path])
-    writer.mapped("rescue", {mappingKind: "anchor", node: statement, path, role: "catch"})
-    writer.synthetic(" ", "rescue spacing", [statement], [path])
-    writer.mapped(writer.errorNameForId(statement.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: statement.catchType, path: `${path}/catchType`, role: "type"})
-    writer.synthetic(" => ", "catch binding separator", [statement.catchBinding], [`${path}/catchBinding`])
-    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
-    writer.synthetic("\n", "line break", [statement], [path])
-    emitBlock(writer, statement.catchBody, `${indent}  `, `${path}/catchBody`)
-    writer.synthetic(indent, "indentation", [statement], [path])
-    writer.mapped("end", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
+    for (const [index, handler] of statement.handlers.entries()) {
+      const handlerPath = `${path}/handlers/${index}`
+      const caught = writer.errorForId(handler.catchType.declarationId)
+
+      writer.synthetic(indent, "indentation", [handler], [handlerPath])
+      writer.mapped("rescue", {mappingKind: "anchor", node: handler, path: handlerPath, role: "catch"})
+      writer.synthetic(" ", "rescue spacing", [handler], [handlerPath])
+      writer.mapped(writer.errorNameForId(handler.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: handler.catchType, path: `${handlerPath}/catchType`, role: "type"})
+      writer.synthetic(" => ", "catch binding separator", [handler.catchBinding], [`${handlerPath}/catchBinding`])
+      writer.mapped(handler.catchBinding.name, {mappingKind: "exact", node: handler.catchBinding, path: `${handlerPath}/catchBinding`, role: "name"})
+      writer.synthetic("\n", "line break", [handler], [handlerPath])
+      emitBlock(writer, handler.catchBody, `${indent}  `, `${handlerPath}/catchBody`)
+    }
+    if (statement.finallyBody) {
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("ensure", {mappingKind: "anchor", node: statement, path, role: "ensure"})
+      writer.synthetic("\n", "line break", [statement], [path])
+      emitBlock(writer, statement.finallyBody, `${indent}  `, `${path}/finallyBody`)
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("end", {mappingKind: "anchor", node: statement.finallyBody, path: `${path}/finallyBody`})
+    } else if (statement.handlers.length > 0) {
+      const lastIndex = statement.handlers.length - 1
+
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("end", {mappingKind: "anchor", node: statement.handlers[lastIndex].catchBody, path: `${path}/handlers/${lastIndex}/catchBody`})
+    } else {
+      writer.synthetic(indent, "indentation", [statement], [path])
+      writer.mapped("end", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    }
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }