semantifold 0.12.0 → 0.14.0

package/src/backends/effects.js

@@ -266,6 +266,7 @@ function semanticTypeForIdentity(identity) {
   if (identity.kind == "RecordType") return {arguments: identity.arguments?.map(semanticTypeForValueIdentity),
     declarationId: identity.declarationId, kind: "RecordType"}
   if (identity.kind == "ReferenceType") return {declarationId: identity.declarationId, kind: "ReferenceType"}
+  if (identity.kind == "InterfaceType") return {declarationId: identity.declarationId, kind: "InterfaceType"}
   if (identity.kind == "OwnedResourceType") return {kind: "OwnedResourceType", resourceId: identity.resourceId}
   if (identity.kind == "OwnedReferenceType") return {declarationId: identity.declarationId, kind: "OwnedReferenceType"}
   return {kind: "TypeVariableReference", location: /** @type {never} */ (undefined), parameterId: identity.parameterId}
@@ -478,7 +479,8 @@ function blockExcluded(block) {
     }
     const nested = statement.kind == "IfStatement" ? [statement.consequent, ...(statement.alternate ? [statement.alternate] : [])] :
       statement.kind == "ForEachStatement" || statement.kind == "ForEachMapStatement" || statement.kind == "WhileStatement" ? [statement.body] :
-        statement.kind == "TryStatement" ? [statement.body, statement.catchBody] : []
+        statement.kind == "TryStatement" ? [statement.body, ...statement.handlers.map((handler) => handler.catchBody),
+          ...(statement.finallyBody ? [statement.finallyBody] : [])] : []
     for (const child of nested) {
       const found = blockExcluded(child)
       if (found) return found

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/php.js

@@ -15,6 +15,7 @@ export function generatePhp(module, writer) {
   emitEffectSupport(writer, module, "php")
   const records = module.records ?? []
   const classes = module.classes ?? []
+  const interfaces = module.interfaces ?? []
   const errors = module.errors ?? []
 
   errors.forEach((error, index) => {
@@ -72,6 +73,12 @@ export function generatePhp(module, writer) {
   })
   if (records.length > 0) writer.synthetic("\n\n", "record/function separator", [module])
 
+  interfaces.forEach((declaration, interfaceIndex) => {
+    if (interfaceIndex > 0) writer.synthetic("\n\n", "interface separator", [declaration], [`/interfaces/${interfaceIndex}`])
+    emitInterface(writer, declaration, interfaceIndex)
+  })
+  if (interfaces.length > 0) writer.synthetic("\n\n", "interface/class separator", [module])
+
   classes.forEach((declaration, classIndex) => {
     if (classIndex > 0) writer.synthetic("\n\n", "reference class separator", [declaration], [`/classes/${classIndex}`])
     emitReferenceClass(writer, declaration, classIndex)
@@ -156,6 +163,15 @@ function emitReferenceClass(writer, declaration, classIndex) {
   writer.mapped("final class", {mappingKind: "anchor", node: declaration, path})
   writer.synthetic(" ", "reference class spacing", [declaration], [path])
   writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, path, role: "name"})
+  const implemented = declaration.implements ?? []
+
+  if (implemented.length > 0) {
+    writer.mapped(" implements ", {mappingKind: "anchor", node: declaration, path})
+    implemented.forEach((reference, referenceIndex) => {
+      if (referenceIndex > 0) writer.mapped(", ", {mappingKind: "anchor", node: declaration, path})
+      emitType(writer, reference, `${path}/implements/${referenceIndex}`, "php")
+    })
+  }
   writer.synthetic(" {\n", "reference class open", [declaration], [path])
   declaration.fields.forEach((field, index) => {
     const fieldPath = `${path}/fields/${index}`
@@ -191,6 +207,44 @@ function emitReferenceClass(writer, declaration, classIndex) {
   writer.mapped("}", {mappingKind: "anchor", node: declaration, path})
 }
 
+/**
+ * Emits one PHP native interface declaration with signature-only members.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").InterfaceDeclaration} declaration - Semantic interface.
+ * @param {number} interfaceIndex - Declaration index.
+ * @returns {void}
+ */
+function emitInterface(writer, declaration, interfaceIndex) {
+  const path = `/interfaces/${interfaceIndex}`
+
+  writer.mapped("interface", {mappingKind: "anchor", node: declaration, path})
+  writer.synthetic(" ", "interface spacing", [declaration], [path])
+  writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, path, role: "name"})
+  const parents = declaration.extends ?? []
+
+  if (parents.length > 0) {
+    writer.mapped(" extends ", {mappingKind: "anchor", node: declaration, path})
+    parents.forEach((parent, parentIndex) => {
+      if (parentIndex > 0) writer.mapped(", ", {mappingKind: "anchor", node: declaration, path})
+      emitType(writer, parent, `${path}/extends/${parentIndex}`, "php")
+    })
+  }
+  writer.synthetic(" {\n", "interface open", [declaration], [path])
+  declaration.methods.forEach((method, methodIndex) => {
+    const methodPath = `${path}/methods/${methodIndex}`
+
+    if (methodIndex > 0) writer.synthetic("\n", "line break", [method], [methodPath])
+    writer.synthetic("    public function ", "interface method scaffolding", [method], [methodPath])
+    writer.mapped(method.name, {mappingKind: "exact", node: method, path: methodPath, role: "name"})
+    emitPhpParameters(writer, method.parameters, `${methodPath}/parameters`)
+    writer.synthetic(": ", "interface method return separator", [method], [methodPath])
+    emitNativePhpType(writer, method.returnType, `${methodPath}/returnType`)
+    writer.mapped(";", {mappingKind: "anchor", node: method, path: methodPath})
+  })
+  writer.synthetic("\n", "line break", [declaration], [path])
+  writer.mapped("}", {mappingKind: "anchor", node: declaration, path})
+}
+
 /**
  * Emits one PHP parameter list.
  * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
@@ -355,7 +409,7 @@ function emitNativePhpType(writer, type, path) {
     })
     return
   }
-  if (type.kind == "ReferenceType" || type.kind == "OwnedResourceType" || type.kind == "OwnedReferenceType") {
+  if (type.kind == "ReferenceType" || type.kind == "InterfaceType" || type.kind == "OwnedResourceType" || type.kind == "OwnedReferenceType") {
     emitType(writer, type, path, "php")
     return
   }
@@ -365,7 +419,7 @@ function emitNativePhpType(writer, type, path) {
   }
   if (type.kind == "OptionalType") {
     writer.mapped("?", {mappingKind: "exact", node: type, path, role: "type"})
-    if (type.valueType.kind == "RecordType") emitNativePhpType(writer, type.valueType, `${path}/valueType`)
+    if (type.valueType.kind == "RecordType" || type.valueType.kind == "InterfaceType") emitNativePhpType(writer, type.valueType, `${path}/valueType`)
     else if (type.valueType.kind == "TypeReference") emitType(writer, type.valueType, `${path}/valueType`, "php")
     else writer.mapped("array", {mappingKind: "anchor", node: type, path})
     return
@@ -489,9 +543,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 +559,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/scalars.js

@@ -37,7 +37,7 @@ export function emitScalarType(language, type) {
  * @returns {string} Exact target spelling.
  */
 export function emitSemanticType(language, type, javaBoxed = false) {
-  if (type.kind == "RecordType" || type.kind == "ReferenceType") {
+  if (type.kind == "RecordType" || type.kind == "ReferenceType" || type.kind == "InterfaceType") {
     throw new TypeError("Nominal type emission requires declaration context.")
   }
   if (type.kind == "OwnedResourceType" || type.kind == "OwnedReferenceType") {