semantifold 0.12.0 → 0.13.0

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
   }

package/src/backends/shared.js

@@ -627,7 +627,8 @@ function rejectBlockConditionLoop(block, language, seen = new Set()) {
       rejectBlockConditionLoop(Reflect.get(statement, "body"), language, seen)
     } else if (kind == "TryStatement") {
       rejectBlockConditionLoop(Reflect.get(statement, "body"), language, seen)
-      rejectBlockConditionLoop(Reflect.get(statement, "catchBody"), language, seen)
+      for (const handler of Reflect.get(statement, "handlers") ?? []) rejectBlockConditionLoop(Reflect.get(handler, "catchBody"), language, seen)
+      rejectBlockConditionLoop(Reflect.get(statement, "finallyBody"), language, seen)
     }
   }
 }
@@ -658,7 +659,8 @@ function rejectBlockIteration(block, language, seen = new Set()) {
       rejectBlockIteration(Reflect.get(statement, "alternate"), language, seen)
     } else if (kind == "TryStatement") {
       rejectBlockIteration(Reflect.get(statement, "body"), language, seen)
-      rejectBlockIteration(Reflect.get(statement, "catchBody"), language, seen)
+      for (const handler of Reflect.get(statement, "handlers") ?? []) rejectBlockIteration(Reflect.get(handler, "catchBody"), language, seen)
+      rejectBlockIteration(Reflect.get(statement, "finallyBody"), language, seen)
     }
   }
 }
@@ -713,7 +715,8 @@ function rejectBlockOptionalTypes(block, language) {
     if (statement.kind == "WhileStatement") rejectBlockOptionalTypes(statement.body, language)
     if (statement.kind == "TryStatement") {
       rejectBlockOptionalTypes(statement.body, language)
-      rejectBlockOptionalTypes(statement.catchBody, language)
+      for (const handler of statement.handlers ?? []) rejectBlockOptionalTypes(handler.catchBody, language)
+      if (statement.finallyBody) rejectBlockOptionalTypes(statement.finallyBody, language)
     }
   }
 }
@@ -788,7 +791,8 @@ function rejectBlockCollectionTypes(block, language) {
     if (statement.kind == "WhileStatement") rejectBlockCollectionTypes(statement.body, language)
     if (statement.kind == "TryStatement") {
       rejectBlockCollectionTypes(statement.body, language)
-      rejectBlockCollectionTypes(statement.catchBody, language)
+      for (const handler of statement.handlers ?? []) rejectBlockCollectionTypes(handler.catchBody, language)
+      if (statement.finallyBody) rejectBlockCollectionTypes(statement.finallyBody, language)
     }
   }
 }
@@ -856,9 +860,13 @@ function validateScaffoldingNames(module, language) {
           }
         }
       }
-      if (statement.kind == "TryStatement" && ownedPrintReceiverNames.has(statement.catchBinding.name)) {
-        unsupportedCapability(language, `${owner} catch binding '${statement.catchBinding.name}' captures backend scaffolding`,
-          statement.catchBinding.location)
+      if (statement.kind == "TryStatement") {
+        for (const handler of statement.handlers ?? []) {
+          if (ownedPrintReceiverNames.has(handler.catchBinding.name)) {
+            unsupportedCapability(language, `${owner} catch binding '${handler.catchBinding.name}' captures backend scaffolding`,
+              handler.catchBinding.location)
+          }
+        }
       }
     }
   }
@@ -878,9 +886,13 @@ function validateScaffoldingNames(module, language) {
         }
       }
     }
-    if (statement.kind == "TryStatement" && ownedEntryNames.has(statement.catchBinding.name)) {
-      unsupportedCapability(language, `entry catch binding '${statement.catchBinding.name}' captures backend scaffolding`,
-        statement.catchBinding.location)
+    if (statement.kind == "TryStatement") {
+      for (const handler of statement.handlers ?? []) {
+        if (ownedEntryNames.has(handler.catchBinding.name)) {
+          unsupportedCapability(language, `entry catch binding '${handler.catchBinding.name}' captures backend scaffolding`,
+            handler.catchBinding.location)
+        }
+      }
     }
   }
   for (const declaration of module.functions) {
@@ -949,12 +961,13 @@ function validateRecordConstructorNames(module, language) {
           }
         }
       }
-      if (statement.kind == "TryStatement" && recordNames.has(statement.catchBinding.name)) {
-        unsupportedCapability(
-          language,
-          `${owner} catch binding '${statement.catchBinding.name}' captures nominal constructor`,
-          bindingNameLocation(statement.catchBinding)
-        )
+      if (statement.kind == "TryStatement") {
+        const captured = (statement.handlers ?? []).find((handler) => recordNames.has(handler.catchBinding.name))
+
+        if (captured) {
+          unsupportedCapability(language, `${owner} catch binding '${captured.catchBinding.name}' captures nominal constructor`,
+            bindingNameLocation(captured.catchBinding))
+        }
       }
     }
   }
@@ -1052,12 +1065,15 @@ function validateJavaUtilFactoryNames(module) {
       }
       if (statement.kind == "TryStatement") {
         validateBlockNames(statement.body, capture, owner)
-        const catchCapture = statement.catchBinding.name == "java" ? {
-          detail: `${owner} catch binding 'java' captures java.util factory syntax`,
-          location: statement.catchBinding.location
-        } : capture
+        for (const handler of statement.handlers ?? []) {
+          const catchCapture = handler.catchBinding.name == "java" ? {
+            detail: `${owner} catch binding 'java' captures java.util factory syntax`,
+            location: handler.catchBinding.location
+          } : capture
 
-        validateBlockNames(statement.catchBody, catchCapture, owner)
+          validateBlockNames(handler.catchBody, catchCapture, owner)
+        }
+        if (statement.finallyBody) validateBlockNames(statement.finallyBody, capture, owner)
       }
     }
   }
@@ -1220,7 +1236,11 @@ function allStatements(block) {
       return [statement, ...allStatements(statement.body)]
     }
     if (statement.kind == "WhileStatement") return [statement, ...allStatements(statement.body)]
-    if (statement.kind == "TryStatement") return [statement, ...allStatements(statement.body), ...allStatements(statement.catchBody)]
+    if (statement.kind == "TryStatement") {
+      return [statement, ...allStatements(statement.body),
+        ...(statement.handlers ?? []).flatMap((handler) => allStatements(handler.catchBody)),
+        ...(statement.finallyBody ? allStatements(statement.finallyBody) : [])]
+    }
 
     return [statement]
   })
@@ -1274,7 +1294,8 @@ function collectLoopOwners(module, language) {
         visit(Reflect.get(statement, "alternate"), owner, path)
       } else if (kind == "TryStatement") {
         visit(Reflect.get(statement, "body"), owner, path)
-        visit(Reflect.get(statement, "catchBody"), owner, path)
+        for (const handler of Reflect.get(statement, "handlers") ?? []) visit(Reflect.get(handler, "catchBody"), owner, path)
+        visit(Reflect.get(statement, "finallyBody"), owner, path)
       }
     }
   }
@@ -1536,30 +1557,55 @@ function validateStatement(statement, language, ownerLocation, loopContext, acti
     validateExpression(raised.message, language, raised.location, false, new Set(), externalDeclarationIds)
     return
   }
+  if (kind == "RethrowStatement") {
+    const rethrow = /** @type {import("../semantic/types.js").RethrowStatement} */ (statement)
+    const rethrowLocation = requireSemanticLocation(ownLocation, language, "RethrowStatement location", ownerLocation)
+
+    if (Object.keys(rethrow).filter((key) => key != "sourceProvenance").sort().join(",") != "binding,bindingNode,kind,location" ||
+      typeof rethrow.binding != "string" || rethrow.binding.length == 0 ||
+      !rethrow.bindingNode || rethrow.bindingNode.kind != "CatchBinding" || rethrow.bindingNode.name != rethrow.binding) {
+      unsupportedCapability(language, "malformed RethrowStatement", rethrowLocation)
+    }
+    validateTargetBindingIdentifier(language, rethrow.binding, "catch binding", rethrowLocation)
+    return
+  }
   if (kind == "TryStatement") {
-    const handler = /** @type {import("../semantic/types.js").TryStatement} */ (statement)
+    const tryStatement = /** @type {import("../semantic/types.js").TryStatement} */ (statement)
     const tryLocation = requireSemanticLocation(ownLocation, language, "TryStatement location", ownerLocation)
-    const fields = Object.keys(handler).filter((key) => key != "sourceProvenance").sort().join(",")
+    const fields = Object.keys(tryStatement).filter((key) => key != "sourceProvenance").sort().join(",")
 
-    if (fields != "body,catchBinding,catchBody,catchType,kind,location") {
+    if (fields != "body,handlers,kind,location" && fields != "body,finallyBody,handlers,kind,location") {
       unsupportedCapability(language, "malformed TryStatement", tryLocation)
     }
-    validateErrorTypeShape(handler.catchType, language, tryLocation)
-    const binding = handler.catchBinding
-    const bindingFields = binding && typeof binding == "object" && !Array.isArray(binding)
-      ? Object.keys(binding).filter((key) => key != "sourceProvenance").sort().join(",") : ""
-    const bindingLocation = requireSemanticLocation(binding?.location, language, "catch binding location", tryLocation)
-
-    if (!binding || binding.kind != "CatchBinding" || bindingFields != "kind,location,mutable,name,type" || binding.mutable !== false) {
-      unsupportedCapability(language, "malformed catch binding", bindingLocation)
+    if (!Array.isArray(tryStatement.handlers) || (tryStatement.handlers.length == 0 && !tryStatement.finallyBody)) {
+      unsupportedCapability(language, "TryStatement without an ordered handler list", tryLocation)
     }
-    validateTargetBindingIdentifier(language, binding.name, "catch binding", bindingLocation)
-    validateErrorTypeShape(binding.type, language, bindingLocation)
-    if (binding.type.declarationId != handler.catchType.declarationId) {
-      unsupportedCapability(language, "catch binding type mismatch", bindingLocation)
+    validateBlock(tryStatement.body, language, tryLocation, loopContext, activePath, externalDeclarationIds)
+    for (const handler of tryStatement.handlers) {
+      const handlerLocation = requireSemanticLocation(handler?.location, language, "catch handler location", tryLocation)
+      const handlerFields = handler && typeof handler == "object" && !Array.isArray(handler)
+        ? Object.keys(handler).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!handler || handler.kind != "CatchHandler" || handlerFields != "catchBinding,catchBody,catchType,kind,location") {
+        unsupportedCapability(language, "malformed catch handler", handlerLocation)
+      }
+      validateErrorTypeShape(handler.catchType, language, handlerLocation)
+      const binding = handler.catchBinding
+      const bindingFields = binding && typeof binding == "object" && !Array.isArray(binding)
+        ? Object.keys(binding).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+      const bindingLocation = requireSemanticLocation(binding?.location, language, "catch binding location", handlerLocation)
+
+      if (!binding || binding.kind != "CatchBinding" || bindingFields != "kind,location,mutable,name,type" || binding.mutable !== false) {
+        unsupportedCapability(language, "malformed catch binding", bindingLocation)
+      }
+      validateTargetBindingIdentifier(language, binding.name, "catch binding", bindingLocation)
+      validateErrorTypeShape(binding.type, language, bindingLocation)
+      if (binding.type.declarationId != handler.catchType.declarationId) {
+        unsupportedCapability(language, "catch binding type mismatch", bindingLocation)
+      }
+      validateBlock(handler.catchBody, language, handlerLocation, loopContext, activePath, externalDeclarationIds)
     }
-    validateBlock(handler.body, language, tryLocation, loopContext, activePath, externalDeclarationIds)
-    validateBlock(handler.catchBody, language, tryLocation, loopContext, activePath, externalDeclarationIds)
+    if (tryStatement.finallyBody) validateBlock(tryStatement.finallyBody, language, tryLocation, loopContext, activePath, externalDeclarationIds)
     return
   }
 
@@ -2664,7 +2710,8 @@ function blockContainsSignProducingOperation(block) {
       return expressionContainsSignProducingOperation(statement.condition) || blockContainsSignProducingOperation(statement.body)
     }
     if (statement.kind == "TryStatement") {
-      return blockContainsSignProducingOperation(statement.body) || blockContainsSignProducingOperation(statement.catchBody)
+      return blockContainsSignProducingOperation(statement.body) || (statement.handlers ?? []).some((handler) => blockContainsSignProducingOperation(handler.catchBody)) ||
+        (statement.finallyBody ? blockContainsSignProducingOperation(statement.finallyBody) : false)
     }
     if (statement.kind == "RaiseStatement") return expressionContainsSignProducingOperation(statement.error.message)
     if (statement.kind == "LocalDeclaration") return expressionContainsSignProducingOperation(statement.initializer)

package/src/backends/typescript.js

@@ -376,10 +376,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`})
@@ -387,21 +391,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) emitTypeScriptHandler(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
   }
@@ -453,6 +451,73 @@ function emitStatement(writer, statement, indent, path, canonicalizeZero) {
   writer.synthetic("\n", "line break", [statement], [path])
 }
 
+/**
+ * Emits one ordered TypeScript catch handler with its exact nominal guard.
+ *
+ * TypeScript 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 emitTypeScriptHandler(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) {
+    emitTypeScriptDispatch(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 emitTypeScriptDispatch(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])
+  emitTypeScriptHandler(writer, statement, index + 1, `${indent}  `, path, canonicalizeZero)
+}
+
 /**
  * Emits one TypeScript local statement.
  * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.

package/src/frontends/java.js

@@ -4,7 +4,7 @@ import {parser} from "@lezer/java"
 import {SemantifoldDiagnostic, missingType, unsupportedSyntax} from "../diagnostic.js"
 import {locationFromOffsets, moduleLocation} from "../semantic/location.js"
 import {withAdaptedOperation} from "../semantic/operators.js"
-import {withParserRanges} from "../semantic/provenance.js"
+import {setParserRanges, withParserRanges} from "../semantic/provenance.js"
 import {hasOnlyUnicodeScalars} from "../semantic/scalars.js"
 import {isTask034ResourceProbe} from "../semantic/capabilities.js"
 import {hasExactEffectSupport} from "../backends/effects.js"
@@ -41,6 +41,8 @@ const referenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass",
 /**
  * @typedef JavaConversionContext
  * @property {Map<string, import("../semantic/types.js").SemanticBindingType>} bindings - Explicitly typed visible bindings.
+ * @property {Set<string>} [catchBindingNames] - Lexically visible exact catch binding names.
+ * @property {Map<string, import("../semantic/types.js").CatchBinding>} [catchBindingNodes] - Exact catch binding nodes by visible name.
  * @property {Map<string, import("../semantic/types.js").ClassDeclaration>} classes - Reference classes by identity.
  * @property {import("../semantic/types.js").ClassDeclaration} [currentClass] - Enclosing reference class.
  * @property {Map<string, import("../semantic/types.js").ErrorDeclaration>} errorNames - Errors by source name.
@@ -970,7 +972,7 @@ function convertStatement(statement, filename, source, context) {
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
  * @param {JavaConversionContext} context - Typed lexical context.
- * @returns {import("../semantic/types.js").RaiseStatement} Semantic raise.
+ * @returns {import("../semantic/types.js").RaiseStatement | import("../semantic/types.js").RethrowStatement} Semantic raise or rethrow.
  */
 function convertJavaRaise(statement, filename, source, context) {
   const location = nodeLocation(statement, filename, source)
@@ -980,6 +982,23 @@ function convertJavaRaise(statement, filename, source, context) {
   const arguments_ = argumentsNode ? structuralChildren(argumentsNode) : []
   const declaration = typeNode ? context.errorNames.get(nodeText(typeNode, source)) : undefined
 
+  if (!construction && arguments_.length == 0) {
+    const throwNode = requiredChild(statement, "throw", filename, source)
+    const rethrown = structuralChildren(statement).find((candidate) => candidate.name == "Identifier")
+    const binding = rethrown ? context.bindings.get(nodeText(rethrown, source)) : undefined
+
+    if (rethrown && binding?.kind == "ErrorType" && context.catchBindingNames?.has(nodeText(rethrown, source))) {
+      const bindingNode = context.catchBindingNodes?.get(nodeText(rethrown, source))
+
+      if (!bindingNode) return unsupportedSyntax("java", "throw of a catch binding without an exact handler binding", location)
+      return withParserRanges({
+        binding: nodeText(rethrown, source),
+        bindingNode,
+        kind: /** @type {const} */ ("RethrowStatement"),
+        location
+      }, {keyword: nodeLocation(throwNode, filename, source)})
+    }
+  }
   if (!construction || !typeNode || !argumentsNode || !declaration || arguments_.length != 1 || construction.getChild("ClassBody")) {
     return unsupportedSyntax("java", "throw other than exact declared error construction", location)
   }
@@ -1009,46 +1028,76 @@ function convertJavaTry(statement, filename, source, context) {
   const location = nodeLocation(statement, filename, source)
   const body = statement.getChild("Block")
   const catches = statement.getChildren("CatchClause")
+  const finalizer = statement.getChild("FinallyClause")
+
+  if (!body || (catches.length == 0 && !finalizer) || statement.getChild("ResourceSpecification")) {
+    return unsupportedSyntax("java", "try without catches or finally and without resources", location)
+  }
+  /** @type {import("../semantic/types.js").CatchHandler[]} */
+  const handlers = []
+  const seenHandlerNames = new Set(context.catchBindingNames ?? [])
+
+  for (const handler of catches) {
+    const parameter = handler.getChild("CatchFormalParameter")
+    const caught = parameter?.getChild("CatchType")
+    const typeNodes = caught ? structuralChildren(caught) : []
+    const definition = parameter?.getChild("Definition")
+    const catchBody = handler.getChild("Block")
+    const typeNode = typeNodes[0]
+    const declaration = typeNode ? context.errorNames.get(nodeText(typeNode, source)) : undefined
+
+    if (!parameter || !caught || typeNodes.length != 1 || typeNode?.name != "TypeName" || !definition || !catchBody || !declaration ||
+      parameter.getChild("Modifiers")) {
+      return unsupportedSyntax("java", "broad, multiple, or malformed catch", nodeLocation(handler, filename, source))
+    }
+    const name = nodeText(definition, source)
 
-  if (!body || catches.length != 1 || statement.getChild("FinallyClause") || statement.getChild("ResourceSpecification")) {
-    return unsupportedSyntax("java", "try without one catch and no resources or finally", location)
-  }
-  const handler = catches[0]
-  const parameter = handler.getChild("CatchFormalParameter")
-  const caught = parameter?.getChild("CatchType")
-  const typeNodes = caught ? structuralChildren(caught) : []
-  const definition = parameter?.getChild("Definition")
-  const catchBody = handler.getChild("Block")
-  const typeNode = typeNodes[0]
-  const declaration = typeNode ? context.errorNames.get(nodeText(typeNode, source)) : undefined
-
-  if (!parameter || !caught || typeNodes.length != 1 || typeNode?.name != "TypeName" || !definition || !catchBody || !declaration ||
-    parameter.getChild("Modifiers")) {
-    return unsupportedSyntax("java", "broad, multiple, or malformed catch", nodeLocation(handler, filename, source))
-  }
-  const caughtLocation = nodeLocation(typeNode, filename, source)
-  const catchType = withParserRanges({declarationId: /** @type {string} */ (declaration.id), kind: /** @type {const} */ ("ErrorType")}, {
-    type: caughtLocation
-  })
-  const bodyContext = {...context, bindings: new Map(context.bindings), erasedBindingNames: new Set(context.erasedBindingNames)}
-  const catchContext = {...context, bindings: new Map(context.bindings), erasedBindingNames: new Set(context.erasedBindingNames)}
-  const name = nodeText(definition, source)
+    if (seenHandlerNames.has(name)) {
+      return unsupportedSyntax("java", `catch binding '${name}' shadows an outer handler binding`, nodeLocation(definition, filename, source))
+    }
+    seenHandlerNames.add(name)
+    const caughtLocation = nodeLocation(typeNode, filename, source)
+    const catchType = withParserRanges({declarationId: /** @type {string} */ (declaration.id), kind: /** @type {const} */ ("ErrorType")}, {
+      type: caughtLocation
+    })
+    const catchContext = {...context, bindings: new Map(context.bindings), erasedBindingNames: new Set(context.erasedBindingNames),
+      catchBindingNames: new Set(seenHandlerNames), catchBindingNodes: new Map(context.catchBindingNodes)}
 
-  catchContext.bindings.set(name, catchType)
-  return withParserRanges({
-    body: convertBlock(body, filename, source, bodyContext),
-    catchBinding: withParserRanges({
+    catchContext.bindings.set(name, catchType)
+    const catchBindingNode = withParserRanges({
       kind: /** @type {const} */ ("CatchBinding"),
       location: nodeLocation(definition, filename, source),
       mutable: /** @type {const} */ (false),
       name,
       type: catchType
-    }, {name: nodeLocation(definition, filename, source)}),
-    catchBody: convertBlock(catchBody, filename, source, catchContext),
-    catchType,
+    }, {name: nodeLocation(definition, filename, source)})
+
+    catchContext.catchBindingNodes.set(name, catchBindingNode)
+    handlers.push(withParserRanges({
+      catchBinding: catchBindingNode,
+      catchBody: convertBlock(catchBody, filename, source, catchContext),
+      catchType,
+      kind: /** @type {const} */ ("CatchHandler"),
+      location: nodeLocation(handler, filename, source)
+    }, {catch: nodeLocation(handler, filename, source)}))
+  }
+  const bodyContext = {...context, bindings: new Map(context.bindings), erasedBindingNames: new Set(context.erasedBindingNames)}
+  const semantic = /** @type {import("../semantic/types.js").TryStatement} */ (withParserRanges({
+    body: convertBlock(body, filename, source, bodyContext),
+    handlers,
     kind: /** @type {const} */ ("TryStatement"),
     location
-  }, {catch: nodeLocation(handler, filename, source), try: nodeLocation(requiredChild(statement, "try", filename, source), filename, source)})
+  }, {try: nodeLocation(requiredChild(statement, "try", filename, source), filename, source)}))
+
+  if (finalizer) {
+    const finallyBlock = finalizer.getChild("Block")
+
+    if (!finallyBlock) return unsupportedSyntax("java", "malformed finally block", nodeLocation(finalizer, filename, source))
+    semantic.finallyBody = convertBlock(finallyBlock, filename, source, bodyContext)
+    setParserRanges(semantic, {finally: nodeLocation(finalizer, filename, source),
+      try: nodeLocation(requiredChild(statement, "try", filename, source), filename, source)})
+  }
+  return semantic
 }
 
 /**