semantifold 0.12.0 → 0.14.0

package/src/backends/shared.js

@@ -38,6 +38,7 @@ const task014Languages = new Set(["php", "ruby", "javascript", "typescript", "ja
 const task032Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task033Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task048ConditionalLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"])
+const boundedSubtypingLanguages = new Set(["php"])
 const javaReferenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait"])
 const javascriptReferenceMethodHooks = new Set([
   "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor",
@@ -56,7 +57,7 @@ const javaObjectInstanceMethodSignatures = new Set([
  * Checks the intentionally narrow backend contract.
  * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
  * @param {import("../semantic/types.js").BackendLanguage} language - Backend language or binary target.
- * @param {{externalDeclarationIds?: Set<string>, program?: boolean, visibleFunctions?: Map<string, import("../semantic/types.js").FunctionDeclaration>, visibleRecords?: Map<string, import("../semantic/types.js").RecordDeclaration>, visibleClasses?: Map<string, import("../semantic/types.js").ClassDeclaration>, visibleErrors?: Map<string, import("../semantic/types.js").ErrorDeclaration>, visibleCallEffects?: Map<string, Set<string>>}} [options] - Resolved program validation context.
+ * @param {{externalDeclarationIds?: Set<string>, program?: boolean, visibleFunctions?: Map<string, import("../semantic/types.js").FunctionDeclaration>, visibleRecords?: Map<string, import("../semantic/types.js").RecordDeclaration>, visibleClasses?: Map<string, import("../semantic/types.js").ClassDeclaration>, visibleInterfaces?: Map<string, import("../semantic/types.js").InterfaceDeclaration>, visibleErrors?: Map<string, import("../semantic/types.js").ErrorDeclaration>, visibleCallEffects?: Map<string, Set<string>>}} [options] - Resolved program validation context.
  * @returns {void}
  */
 export function validateBackendModule(module, language, options = {}) {
@@ -89,11 +90,19 @@ export function validateBackendModule(module, language, options = {}) {
   if (classes.length > 0 && !task033Languages.has(language)) {
     unsupportedCapability(language, "Task 033 reference classes, methods, and constructors", classes[0]?.location ?? module.location)
   }
+  const declaredInterfaces = module.interfaces
+  const interfaces = declaredInterfaces === undefined ? [] : declaredInterfaces
+
+  if (!Array.isArray(interfaces)) unsupportedCapability(language, "missing or invalid interface declarations", module.location)
+  if (interfaces.length > 0 && !boundedSubtypingLanguages.has(language)) {
+    unsupportedCapability(language, "Task 048 bounded subtyping interfaces", interfaces[0]?.location ?? module.location)
+  }
   if (!task011Languages.has(language)) rejectTypedErrors(module, language)
   if (!task032Languages.has(language)) rejectConditionControlledLoops(module, language)
   if (!task014Languages.has(language)) rejectOrderedMapCapability(module, language)
   validateRecordTargets(records, module.functions, language, module.location)
-  validateReferenceClassTargets(classes, records, errors, module.functions, language, module.location)
+  validateInterfaceTargets(interfaces, records, errors, module.functions, language, module.location)
+  validateReferenceClassTargets(classes, records, errors, module.functions, interfaces, language, module.location)
   if (!task008Languages.has(language)) rejectIterationStatements(module, language)
   if (!task007Languages.has(language)) rejectOptionalTypes(module, language)
   if (!task006Languages.has(language)) rejectCollectionTypes(module, language)
@@ -163,6 +172,7 @@ export function validateBackendModule(module, language, options = {}) {
     classes: options.visibleClasses,
     errors: options.visibleErrors,
     functions: options.visibleFunctions,
+    interfaces: options.visibleInterfaces,
     records: options.visibleRecords
   })
 }
@@ -382,7 +392,99 @@ function validateRecordTargets(records, functions, language, moduleLocation) {
  * @param {import("../semantic/types.js").SourceLocation | undefined} moduleLocation - Fallback location.
  * @returns {void}
  */
-function validateReferenceClassTargets(classes, records, errors, functions, language, moduleLocation) {
+/**
+ * Validates the exact target-visible shape of every interface and its override contracts before output allocation.
+ * @param {import("../semantic/types.js").InterfaceDeclaration[]} interfaces - Candidate interfaces.
+ * @param {import("../semantic/types.js").RecordDeclaration[]} records - Existing records.
+ * @param {import("../semantic/types.js").ErrorDeclaration[]} errors - Existing typed errors.
+ * @param {import("../semantic/types.js").FunctionDeclaration[]} functions - Existing functions.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} moduleLocation - Fallback location.
+ * @returns {void}
+ */
+function validateInterfaceTargets(interfaces, records, errors, functions, language, moduleLocation) {
+  if (interfaces.length == 0) return
+  const byId = new Map(interfaces.map((declaration) => [declaration.id, declaration]))
+  const targetNames = new Set()
+
+  for (const declaration of [...records, ...errors, ...functions]) {
+    if (!declaration || typeof declaration != "object" || Array.isArray(declaration)) continue
+    const name = Reflect.get(declaration, "name")
+
+    if (typeof name == "string") targetNames.add(language == "php" ? name.toLowerCase() : name)
+  }
+
+  for (let interfaceIndex = 0; interfaceIndex < interfaces.length; interfaceIndex += 1) {
+    const declaration = interfaces[interfaceIndex]
+    const location = diagnosticLocation(declaration?.location, moduleLocation)
+    const keys = declaration && typeof declaration == "object" && !Array.isArray(declaration)
+      ? Object.keys(declaration).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+    if (!declaration || declaration.kind != "InterfaceDeclaration" ||
+      !["extends,id,kind,location,methods,name", "id,kind,location,methods,name"].includes(keys) ||
+      !isDenseArray(declaration.methods) ||
+      !new RegExp(`^(?:[a-z][a-z0-9._-]*#)?interface:${interfaceIndex}$`, "u").test(String(declaration.id))) {
+      unsupportedCapability(language, "missing or invalid interface declaration", location)
+    }
+    const declarationLocation = requireSemanticLocation(declaration.location, language, "interface declaration location", location)
+
+    validateTargetTypeIdentifier(language, declaration.name, declarationLocation)
+    const targetName = language == "php" ? declaration.name.toLowerCase() : declaration.name
+
+    if (targetNames.has(targetName)) unsupportedCapability(language, `interface collision '${declaration.name}'`, declarationLocation)
+    targetNames.add(targetName)
+    const methodNames = new Set()
+
+    for (let methodIndex = 0; methodIndex < declaration.methods.length; methodIndex += 1) {
+      const method = declaration.methods[methodIndex]
+      const methodLocation = diagnosticLocation(method?.location, declarationLocation)
+      const methodKeys = method && typeof method == "object" && !Array.isArray(method)
+        ? Object.keys(method).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!method || method.kind != "InterfaceMethodDeclaration" || methodKeys != "id,kind,location,name,parameters,returnType" ||
+        method.id != `${declaration.id}:method:${methodIndex}` || !isDenseArray(method.parameters)) {
+        unsupportedCapability(language, "missing or invalid interface method declaration", methodLocation)
+      }
+      const exactMethodLocation = requireSemanticLocation(method.location, language, "interface method declaration location", declarationLocation)
+
+      validateTargetIdentifier(language, method.name, "interface method", exactMethodLocation)
+      const normalized = language == "php" ? method.name.toLowerCase() : method.name
+
+      if (methodNames.has(normalized)) unsupportedCapability(language, `duplicate interface method '${method.name}'`, exactMethodLocation)
+      methodNames.add(normalized)
+      validateReferenceClassParameters(method.parameters, "interface method", language, exactMethodLocation)
+    }
+    const parents = declaration.extends ?? []
+
+    for (const parent of parents) {
+      const parentKeys = parent && typeof parent == "object" && !Array.isArray(parent)
+        ? Object.keys(parent).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!parent || parent.kind != "InterfaceType" || parentKeys != "declarationId,kind" ||
+        !byId.has(parent.declarationId)) {
+        unsupportedCapability(language, "missing or invalid interface parent reference", declarationLocation)
+      }
+    }
+  }
+  for (const declaration of interfaces) {
+    for (const parent of declaration.extends ?? []) {
+      if (parent.declarationId == declaration.id) unsupportedCapability(language, "interface extends itself", declaration.location)
+    }
+  }
+}
+
+/**
+ * Validates the exact target-visible shape of every reference class before output allocation.
+ * @param {import("../semantic/types.js").ClassDeclaration[]} classes - Candidate classes.
+ * @param {import("../semantic/types.js").RecordDeclaration[]} records - Existing records.
+ * @param {import("../semantic/types.js").ErrorDeclaration[]} errors - Existing typed errors.
+ * @param {import("../semantic/types.js").FunctionDeclaration[]} functions - Existing functions.
+ * @param {import("../semantic/types.js").InterfaceDeclaration[]} interfaces - Existing interfaces.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} moduleLocation - Fallback location.
+ * @returns {void}
+ */
+function validateReferenceClassTargets(classes, records, errors, functions, interfaces, language, moduleLocation) {
   const targetNames = new Set()
 
   for (const declaration of [...records, ...errors, ...functions]) {
@@ -400,7 +502,8 @@ function validateReferenceClassTargets(classes, records, errors, functions, lang
       ? Object.keys(declaration).filter((key) => key != "sourceProvenance").sort().join(",") : ""
 
     if (!declaration || declaration.kind != "ClassDeclaration" ||
-      !["constructor,fields,id,kind,location,methods,name", "constructor,fields,id,kind,location,methods,name,ownership"].includes(keys) ||
+      !["constructor,fields,id,implements,kind,location,methods,name", "constructor,fields,id,implements,kind,location,methods,name,ownership",
+        "constructor,fields,id,kind,location,methods,name", "constructor,fields,id,kind,location,methods,name,ownership"].includes(keys) ||
       !isDenseArray(declaration.fields) || declaration.fields.length == 0 || !isDenseArray(declaration.methods) ||
       !new RegExp(`^(?:[a-z][a-z0-9._-]*#)?class:${classIndex}$`, "u").test(String(declaration.id))) {
       unsupportedCapability(language, "missing or invalid reference class declaration", location)
@@ -459,7 +562,9 @@ function validateReferenceClassTargets(classes, records, errors, functions, lang
         ? Object.keys(method).filter((key) => key != "sourceProvenance").sort().join(",") : ""
 
       if (!method || method.kind != "MethodDeclaration" ||
-        !["body,id,kind,location,name,parameters,returnType",
+        !["body,id,implements,kind,location,name,parameters,returnType",
+          "body,effects,failureIds,id,implements,kind,location,name,parameters,returnType",
+          "body,id,kind,location,name,parameters,returnType",
           "body,effects,failureIds,id,kind,location,name,parameters,returnType"].includes(methodKeys) ||
         method.id != `${declaration.id}:method:${methodIndex}` || !isDenseArray(method.parameters)) {
         unsupportedCapability(language, "missing or invalid method declaration", methodLocation)
@@ -492,13 +597,104 @@ function validateReferenceClassTargets(classes, records, errors, functions, lang
       methodNames.add(normalized)
       validateReferenceClassParameters(method.parameters, "method", language, exactMethodLocation)
     }
+    const implemented = declaration.implements ?? []
+
+    for (const reference of implemented) {
+      const referenceKeys = reference && typeof reference == "object" && !Array.isArray(reference)
+        ? Object.keys(reference).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!reference || reference.kind != "InterfaceType" || referenceKeys != "declarationId,kind" ||
+        !interfaces.some((candidate) => candidate.id == reference.declarationId)) {
+        unsupportedCapability(language, "missing or invalid implemented interface reference", location)
+      }
+    }
+    const satisfied = new Set()
+
+    for (const reference of implemented) {
+      for (const member of flattenedTargetInterfaceMembers(reference.declarationId, interfaces, language, location)) {
+        const method = declaration.methods.find((candidate) => candidate.name == member.name)
+
+        if (!method) unsupportedCapability(language, `interface method '${member.name}' is not implemented`, location)
+        if (satisfied.has(member.name)) unsupportedCapability(language, `duplicate interface implementation '${member.name}'`, location)
+        if (method.parameters.length != member.parameters.length ||
+          method.parameters.some((parameter, index) => !sameTargetType(parameter.type, member.parameters[index].type))) {
+          unsupportedCapability(language, `interface method signature mismatch '${member.name}'`, location)
+        }
+        if (!sameTargetType(method.returnType, member.returnType)) {
+          unsupportedCapability(language, `interface method return mismatch '${member.name}'`, location)
+        }
+        satisfied.add(member.name)
+      }
+    }
+  }
+}
+
+/**
+ * Flattens one target-validated interface signature set in declaration order.
+ * @param {string} interfaceId - Interface identity.
+ * @param {import("../semantic/types.js").InterfaceDeclaration[]} interfaces - Interfaces in declaration order.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Diagnostic location.
+ * @param {Set<string>} [active] - Active extends path.
+ * @returns {import("../semantic/types.js").InterfaceMethodDeclaration[]} Flattened members.
+ */
+function flattenedTargetInterfaceMembers(interfaceId, interfaces, language, location, active = new Set()) {
+  const declaration = interfaces.find((candidate) => candidate.id == interfaceId)
+
+  if (!declaration) unsupportedCapability(language, "missing or invalid implemented interface reference", location)
+  if (active.has(interfaceId)) unsupportedCapability(language, "interface extends itself", declaration.location)
+  active.add(interfaceId)
+  /** @type {import("../semantic/types.js").InterfaceMethodDeclaration[]} */
+  const members = []
+
+  for (const parent of declaration.extends ?? []) {
+    for (const member of flattenedTargetInterfaceMembers(parent.declarationId, interfaces, language, location, active)) {
+      if (!members.some((candidate) => candidate.name == member.name)) members.push(member)
+    }
   }
+  for (const method of declaration.methods) {
+    if (!members.some((candidate) => candidate.name == method.name)) members.push(method)
+  }
+  active.delete(interfaceId)
+
+  return members
+}
+
+/**
+ * Compares two backend-validated semantic types structurally.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} left - First type.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} right - Second type.
+ * @returns {boolean} Whether the types are identical.
+ */
+function sameTargetType(left, right) {
+  return JSON.stringify(targetTypeIdentity(left)) == JSON.stringify(targetTypeIdentity(right))
+}
+
+/**
+ * Reduces one semantic type to its comparable target identity.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @returns {unknown} Comparable identity.
+ */
+function targetTypeIdentity(type) {
+  if (typeof type == "string") return type
+  if (type.kind == "TypeReference") return type.name
+  if (type.kind == "TypeVariableReference") return {kind: "TypeVariableReference", parameterId: type.parameterId}
+  if (type.kind == "RecordType") return {declarationId: type.declarationId, kind: "RecordType"}
+  if (type.kind == "ReferenceType") return {declarationId: type.declarationId, kind: "ReferenceType"}
+  if (type.kind == "InterfaceType") return {declarationId: type.declarationId, kind: "InterfaceType"}
+  if (type.kind == "OwnedResourceType") return {kind: "OwnedResourceType", resourceId: type.resourceId}
+  if (type.kind == "OwnedReferenceType") return {declarationId: type.declarationId, kind: "OwnedReferenceType"}
+  if (type.kind == "ListType") return {elementType: targetTypeIdentity(type.elementType), kind: "ListType"}
+  if (type.kind == "OptionalType") return {kind: "OptionalType", valueType: targetTypeIdentity(type.valueType)}
+  if (type.kind == "OrderedMapType") return {keyType: targetTypeIdentity(type.keyType), kind: "OrderedMapType", valueType: targetTypeIdentity(type.valueType)}
+
+  return {keyType: targetTypeIdentity(type.keyType), kind: "MapType", valueType: targetTypeIdentity(type.valueType)}
 }
 
 /**
  * Validates one reference callable's exact parameter shape and target names.
  * @param {import("../semantic/types.js").Parameter[]} parameters - Candidate parameters.
- * @param {"constructor" | "method"} owner - Callable kind.
+ * @param {"constructor" | "interface method" | "method"} owner - Callable kind.
  * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
  * @param {import("../semantic/types.js").SourceLocation | undefined} ownerLocation - Fallback location.
  * @returns {void}
@@ -627,7 +823,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 +855,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 +911,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 +987,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 +1056,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 +1082,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 +1157,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 +1261,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 +1432,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 +1490,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 +1753,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
   }
 
@@ -2049,6 +2291,14 @@ export function emitType(writer, type, path, language, javaBoxed = false) {
     })
     return
   }
+  if (type.kind == "InterfaceType") {
+    const declaration = writer.interfaceForId(type.declarationId)
+
+    writer.mapped(writer.interfaceNameForId(type.declarationId), {
+      mappingKind: "exact", name: declaration.name, node: type, path, role: "type"
+    })
+    return
+  }
   if (type.kind == "OwnedResourceType") {
     const resource = writer.resourceForId(type.resourceId)
     writer.mapped(writer.capabilityNominalName(resource.name), {mappingKind: "exact", name: resource.name, node: type, path, role: "type"})
@@ -2664,7 +2914,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.