semantifold 0.11.0 → 0.13.0

package/src/frontends/ruby.js

@@ -49,7 +49,7 @@ import {missingType, SemantifoldDiagnostic, unsupportedSyntax} from "../diagnost
 import {blockReferencesProtectedEntry} from "../semantic/effects.js"
 import {locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset} 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, scalarType} from "../semantic/scalars.js"
 import {isTask034ResourceProbe} from "../semantic/capabilities.js"
 import {hasExactEffectSupport} from "../backends/effects.js"
@@ -61,7 +61,7 @@ const referenceMethodHooks = new Set([
   "respond_to_missing?", "send", "singleton_class", "size"
 ])
 /** @typedef {{name: string, nameLocation: import("../semantic/types.js").SourceLocation, parameters: import("../semantic/types.js").Parameter[], returnType: import("../semantic/types.js").SemanticFunctionReturnType, typeParameters?: import("../semantic/types.js").TypeParameter[], location: import("../semantic/types.js").SourceLocation}} RubyFunctionSignature */
-/** @typedef {{bindings: Map<string, import("../semantic/types.js").SemanticBindingType>, classes: Map<string, import("../semantic/types.js").ClassDeclaration>, currentClass?: import("../semantic/types.js").ClassDeclaration, errorNames: Map<string, import("../semantic/types.js").ErrorDeclaration>, errors: Map<string, import("../semantic/types.js").ErrorDeclaration>, functions: Map<string, RubyFunctionSignature>, orderedMapDeclarations?: Set<object>, records: Map<string, import("../semantic/types.js").RecordDeclaration>, recordNames: Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>, loopDepth?: number, returnType?: import("../semantic/types.js").SemanticFunctionReturnType, typeParameters?: Map<string, import("../semantic/types.js").TypeParameter>}} RubyConversionContext */
+/** @typedef {{bindings: Map<string, import("../semantic/types.js").SemanticBindingType>, catchBindingNames?: Set<string>, classes: Map<string, import("../semantic/types.js").ClassDeclaration>, catchBindingNodes?: Map<string, import("../semantic/types.js").CatchBinding>, currentCatchBindingNode?: import("../semantic/types.js").CatchBinding, currentClass?: import("../semantic/types.js").ClassDeclaration, errorNames: Map<string, import("../semantic/types.js").ErrorDeclaration>, errors: Map<string, import("../semantic/types.js").ErrorDeclaration>, functions: Map<string, RubyFunctionSignature>, orderedMapDeclarations?: Set<object>, records: Map<string, import("../semantic/types.js").RecordDeclaration>, recordNames: Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>, loopDepth?: number, returnType?: import("../semantic/types.js").SemanticFunctionReturnType, typeParameters?: Map<string, import("../semantic/types.js").TypeParameter>}} RubyConversionContext */
 const rubyBinaryOperations = new Map([
   ["+", "Add"],
   ["-", "Subtract"],
@@ -969,15 +969,38 @@ function convertStatement(node, comments, context, filename, source) {
  * @param {RubyConversionContext} context - Typed lexical context.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
- * @returns {import("../semantic/types.js").RaiseStatement} Semantic raise.
+ * @returns {import("../semantic/types.js").RaiseStatement | import("../semantic/types.js").RethrowStatement} Semantic raise or rethrow.
  */
 function convertRubyRaise(node, context, filename, source) {
   const location = nodeLocation(node, filename, source)
   const arguments_ = node.arguments_?.arguments_ ?? []
+
+  if (arguments_.length == 0 && context.currentCatchBindingNode) {
+    return withParserRanges({
+      binding: context.currentCatchBindingNode.name,
+      bindingNode: context.currentCatchBindingNode,
+      kind: /** @type {const} */ ("RethrowStatement"),
+      location
+    }, {keyword: prismLocation(node.messageLoc ?? node.location, filename, source)})
+  }
+  if (arguments_.length == 1 && arguments_[0] instanceof LocalVariableReadNode &&
+    context.catchBindingNames?.has(arguments_[0].name) && context.bindings.get(arguments_[0].name)?.kind == "ErrorType") {
+    const bindingNode = context.catchBindingNodes?.get(arguments_[0].name)
+
+    if (!bindingNode) return unsupportedSyntax("ruby", "raise of a catch binding without an exact handler binding", location)
+    return withParserRanges({
+      binding: arguments_[0].name,
+      bindingNode,
+      kind: /** @type {const} */ ("RethrowStatement"),
+      location
+    }, {keyword: prismLocation(node.messageLoc ?? node.location, filename, source)})
+  }
+  if (node.block || node.callOperatorLoc || arguments_.length != 2) {
+    return unsupportedSyntax("ruby", "raise other than exact declared error and message", location)
+  }
   const errorNode = arguments_[0]
 
-  if (node.block || node.callOperatorLoc || arguments_.length != 2 ||
-    !(errorNode instanceof ConstantReadNode) && !(errorNode instanceof ConstantPathNode) ||
+  if (!(errorNode instanceof ConstantReadNode) && !(errorNode instanceof ConstantPathNode) ||
     !context.errorNames.has(constantPathName(errorNode))) {
     return unsupportedSyntax("ruby", "raise other than exact declared error and message", location)
   }
@@ -997,48 +1020,104 @@ function convertRubyRaise(node, context, filename, source) {
 }
 
 /**
- * Converts one exact typed rescue with no else/ensure.
+ * Converts one exact Prism ensure clause body.
+ * @param {import("@ruby/prism").EnsureNode} node - Prism ensure clause.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @param {RubyConversionContext} context - Typed lexical context.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Block} Semantic finally block.
+ */
+function convertRubyEnsure(node, comments, context, filename, source) {
+  // A completion block gets its own binding scope, like every other block in convertRubyTry: a local
+  // declaration inside `ensure` must not leak back into the enclosing conversion context.
+  return convertBlock(node.statements ?? null, comments, {...context, bindings: new Map(context.bindings)}, filename, source,
+    nodeLocation(node, filename, source))
+}
+
+/**
+ * Converts one begin block with ordered exact typed rescues and an optional ensure completion block.
  * @param {BeginNode} node - Prism begin node.
  * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Parser-owned comments.
  * @param {RubyConversionContext} context - Typed lexical context.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
- * @returns {import("../semantic/types.js").TryStatement} Semantic exact handler.
+ * @returns {import("../semantic/types.js").TryStatement} Semantic exact handler chain.
  */
 function convertRubyTry(node, comments, context, filename, source) {
   const location = nodeLocation(node, filename, source)
-  const handler = node.rescueClause
 
-  if (!(handler instanceof RescueNode) || handler.subsequent || node.elseClause || node.ensureClause ||
-    handler.exceptions.length != 1 ||
-    !(handler.exceptions[0] instanceof ConstantReadNode) && !(handler.exceptions[0] instanceof ConstantPathNode) ||
-    !context.errorNames.has(constantPathName(handler.exceptions[0])) || !(handler.reference instanceof LocalVariableTargetNode)) {
-    return unsupportedSyntax("ruby", "begin without one exact typed rescue and binding", location)
+  if (node.elseClause) return unsupportedSyntax("ruby", "begin else clause", nodeLocation(node.elseClause, filename, source))
+  /** @type {import("../semantic/types.js").CatchHandler[]} */
+  const handlers = []
+  const seenHandlerNames = new Set(context.catchBindingNames ?? [])
+  let handler = node.rescueClause
+
+  if (!(handler instanceof RescueNode)) {
+    if (node.ensureClause) {
+      return withParserRanges({
+        body: convertBlock(node.statements, comments, context, filename, source, location),
+        handlers,
+        kind: /** @type {const} */ ("TryStatement"),
+        location,
+        finallyBody: convertRubyEnsure(node.ensureClause, comments, context, filename, source)
+      }, {ensure: nodeLocation(node.ensureClause, filename, source), try: location})
+    }
+    return unsupportedSyntax("ruby", "begin without rescue or ensure", location)
   }
-  const errorNode = handler.exceptions[0]
-  const declaration = /** @type {import("../semantic/types.js").ErrorDeclaration} */ (context.errorNames.get(constantPathName(errorNode)))
-  const caughtLocation = nodeLocation(errorNode, filename, source)
-  const catchType = withParserRanges({declarationId: /** @type {string} */ (declaration.id), kind: /** @type {const} */ ("ErrorType")}, {
-    type: caughtLocation
-  })
   const bodyContext = {...context, bindings: new Map(context.bindings)}
-  const catchContext = {...context, bindings: new Map(context.bindings)}
+  while (handler instanceof RescueNode) {
+    if (handler.exceptions.length != 1 ||
+      !(handler.exceptions[0] instanceof ConstantReadNode) && !(handler.exceptions[0] instanceof ConstantPathNode) ||
+      !context.errorNames.has(constantPathName(handler.exceptions[0])) || !(handler.reference instanceof LocalVariableTargetNode)) {
+      return unsupportedSyntax("ruby", "rescue without one exact typed exception and binding", nodeLocation(handler, filename, source))
+    }
+    if (seenHandlerNames.has(handler.reference.name)) {
+      return unsupportedSyntax("ruby", `rescue binding '${handler.reference.name}' shadows an outer handler binding`,
+        nodeLocation(handler.reference, filename, source))
+    }
+    seenHandlerNames.add(handler.reference.name)
+    const errorNode = handler.exceptions[0]
+    const declaration = /** @type {import("../semantic/types.js").ErrorDeclaration} */ (context.errorNames.get(constantPathName(errorNode)))
+    const caughtLocation = nodeLocation(errorNode, filename, source)
+    const catchType = withParserRanges({declarationId: /** @type {string} */ (declaration.id), kind: /** @type {const} */ ("ErrorType")}, {
+      type: caughtLocation
+    })
+    const catchContext = {...context, bindings: new Map(context.bindings), catchBindingNames: new Set(seenHandlerNames),
+      catchBindingNodes: new Map(context.catchBindingNodes)}
 
-  catchContext.bindings.set(handler.reference.name, catchType)
-  return withParserRanges({
-    body: convertBlock(node.statements, comments, bodyContext, filename, source, location),
-    catchBinding: withParserRanges({
+    catchContext.bindings.set(handler.reference.name, catchType)
+    const catchBindingNode = withParserRanges({
       kind: /** @type {const} */ ("CatchBinding"),
       location: nodeLocation(handler.reference, filename, source),
       mutable: /** @type {const} */ (false),
       name: handler.reference.name,
       type: catchType
-    }, {name: nodeLocation(handler.reference, filename, source)}),
-    catchBody: convertBlock(handler.statements, comments, catchContext, filename, source, nodeLocation(handler, filename, source)),
-    catchType,
+    }, {name: nodeLocation(handler.reference, filename, source)})
+
+    catchContext.catchBindingNodes.set(handler.reference.name, catchBindingNode)
+    catchContext.currentCatchBindingNode = catchBindingNode
+    handlers.push(withParserRanges({
+      catchBinding: catchBindingNode,
+      catchBody: convertBlock(handler.statements, comments, catchContext, filename, source, nodeLocation(handler, filename, source)),
+      catchType,
+      kind: /** @type {const} */ ("CatchHandler"),
+      location: nodeLocation(handler, filename, source)
+    }, {catch: nodeLocation(handler, filename, source)}))
+    handler = handler.subsequent
+  }
+  const semantic = /** @type {import("../semantic/types.js").TryStatement} */ (withParserRanges({
+    body: convertBlock(node.statements, comments, bodyContext, filename, source, location),
+    handlers,
     kind: /** @type {const} */ ("TryStatement"),
     location
-  }, {catch: nodeLocation(handler, filename, source), try: location})
+  }, {try: location}))
+
+  if (node.ensureClause) {
+    semantic.finallyBody = convertRubyEnsure(node.ensureClause, comments, context, filename, source)
+    setParserRanges(semantic, {ensure: nodeLocation(node.ensureClause, filename, source), try: location})
+  }
+  return semantic
 }
 
 /**

package/src/language-registry.js

@@ -571,6 +571,21 @@ const records = [
     artifactMultiplicity: "multiple",
     check: {factory: createCCheckPlan, stages: ["compile", "link"], toolchains: ["clang"]},
     defaultFilename: "program.c",
+    features: {
+      closedRecords: false,
+      conditionControlledLoops: false,
+      conditionalExpressions: false,
+      stringInterpolation: false,
+      effectfulCapabilitiesAndResources: false,
+      generalFunctionsAndCalls: true,
+      immutableCollections: false,
+      optionalValues: false,
+      orderedListIteration: false,
+      orderedMapIteration: false,
+      referenceClasses: false,
+      typedErrors: false,
+      typeParametersAndGenerics: false
+    },
     frontend: parseC,
     id: "c",
     mediaType: "text/x-c",

package/src/semantic/effects.js

@@ -379,10 +379,19 @@ function escapingBlockFailures(block, functionSummaries, methodSummaries, capabi
 
   for (const statement of block.statements) {
     if (statement.kind == "TryStatement") {
-      const body = escapingBlockFailures(statement.body, functionSummaries, methodSummaries, capabilityFailureIds)
+      let body = escapingBlockFailures(statement.body, functionSummaries, methodSummaries, capabilityFailureIds)
 
-      if (body.delete(statement.catchType.declarationId)) {
-        addFailures(result, escapingBlockFailures(statement.catchBody, functionSummaries, methodSummaries, capabilityFailureIds))
+      for (const handler of statement.handlers ?? []) {
+        const caughtId = handler.catchType?.declarationId
+
+        if (typeof caughtId == "string" && body.delete(caughtId)) {
+          addFailures(body, escapingBlockFailures(handler.catchBody, functionSummaries, methodSummaries, capabilityFailureIds))
+        }
+      }
+      if (statement.finallyBody) {
+        // A completion block that can raise replaces the pending completion on the paths where it does,
+        // but pending failures still escape on the paths where it completes normally, so both are reachable.
+        addFailures(body, escapingBlockFailures(statement.finallyBody, functionSummaries, methodSummaries, capabilityFailureIds))
       }
       addFailures(result, body)
       continue
@@ -639,7 +648,9 @@ function forEachBlockExpression(block, visitor, postorder) {
       visit(statement.condition); forEachBlockExpression(statement.body, visitor, postorder)
     } else if (statement.kind == "RaiseStatement") visit(statement.error.message)
     else if (statement.kind == "TryStatement") {
-      forEachBlockExpression(statement.body, visitor, postorder); forEachBlockExpression(statement.catchBody, visitor, postorder)
+      forEachBlockExpression(statement.body, visitor, postorder)
+      for (const handler of statement.handlers) forEachBlockExpression(handler.catchBody, visitor, postorder)
+      if (statement.finallyBody) forEachBlockExpression(statement.finallyBody, visitor, postorder)
     }
   }
 
@@ -694,7 +705,8 @@ function statementReferencesProtectedEntry(statement) {
     case "RaiseStatement":
       return expressionReferencesProtectedEntry(statement.error.message)
     case "TryStatement":
-      return blockReferencesProtectedEntry(statement.body) || blockReferencesProtectedEntry(statement.catchBody)
+      return blockReferencesProtectedEntry(statement.body) || statement.handlers.some((handler) => blockReferencesProtectedEntry(handler.catchBody)) ||
+        (statement.finallyBody ? blockReferencesProtectedEntry(statement.finallyBody) : false)
     default:
       return false
   }

package/src/semantic/lifetime.js

@@ -123,6 +123,10 @@ function analyzeStatement(statement, state, fail, locals, errorEffects) {
       ? {errorId: statement.error.error.declarationId, kind: "raise", location: statement.location, state: flow.state}
       : {...flow, location: statement.location})
   }
+  if (statement.kind == "RethrowStatement") {
+    // A rethrow re-raises the caught binding's exact nominal type, so an enclosing handler must see it.
+    return [{errorId: statement.bindingNode?.type?.declarationId, kind: "raise", location: statement.location, state: cloneState(state)}]
+  }
   if (statement.kind == "IfStatement") {
     const conditions = evaluateExpression(statement.condition, cloneState(state), fail, errorEffects)
     /** @type {LifetimeExit[]} */
@@ -142,10 +146,32 @@ function analyzeStatement(statement, state, fail, locals, errorEffects) {
   if (statement.kind == "TryStatement") {
     const bodyExits = analyzeBlock(statement.body, [{kind: "normal", state: cloneState(state)}], fail, errorEffects)
     /** @type {LifetimeExit[]} */
-    const result = bodyExits.filter((flow) => flow.kind != "raise" || flow.errorId != statement.catchType.declarationId)
+    let result = bodyExits
+
+    for (const handler of statement.handlers ?? []) {
+      const caughtId = handler.catchType?.declarationId
+      const caught = result.filter((flow) => flow.kind == "raise" && flow.errorId == caughtId)
+
+      if (caught.length == 0) continue
+      result = result.filter((flow) => flow.kind != "raise" || flow.errorId != caughtId)
+      for (const flow of caught) {
+        result.push(...analyzeBlock(handler.catchBody, [{kind: "normal", state: cloneState(flow.state)}], fail, errorEffects))
+      }
+    }
+    if (statement.finallyBody) {
+      /** @type {LifetimeExit[]} */
+      const afterFinally = []
+
+      for (const flow of result) {
+        const finallyExits = analyzeBlock(statement.finallyBody, [{kind: "normal", state: cloneState(flow.state)}], fail, errorEffects)
 
-    for (const caught of bodyExits.filter((flow) => flow.kind == "raise" && flow.errorId == statement.catchType.declarationId)) {
-      result.push(...analyzeBlock(statement.catchBody, [{kind: "normal", state: cloneState(caught.state)}], fail, errorEffects))
+        for (const finallyExit of finallyExits) {
+          afterFinally.push(finallyExit.kind == "normal"
+            ? {...flow, location: statement.location}
+            : {...finallyExit, location: statement.location})
+        }
+      }
+      result = afterFinally
     }
     return mergeEquivalentNormals(result, statement.location, fail)
   }

package/src/semantic/provenance.js

@@ -580,8 +580,14 @@ export function semanticEntries(module) {
       visit(node.body, `${path}/body`, location)
     } else if (node.kind == "RaiseStatement") {
       visit(node.error, `${path}/error`, location)
+    } else if (node.kind == "RethrowStatement") {
+      visit(node.bindingNode, `${path}/bindingNode`, location)
+      visit(node.bindingNode, `${path}/bindingNode/name`, location)
     } else if (node.kind == "TryStatement") {
       visit(node.body, `${path}/body`, location)
+      node.handlers.forEach((child, index) => visit(child, `${path}/handlers/${index}`, location))
+      if (node.finallyBody) visit(node.finallyBody, `${path}/finallyBody`, location)
+    } else if (node.kind == "CatchHandler") {
       visit(node.catchType, `${path}/catchType`, location)
       visit(node.catchBinding, `${path}/catchBinding`, location)
       visit(node.catchBody, `${path}/catchBody`, location)
@@ -895,19 +901,28 @@ function resolveSymbols(module, records) {
         visitType(statement.error.error, `${statementPath}/error/error`)
         reference(statement.error, errorSymbols.get(statement.error.error.declarationId), "construct", `${statementPath}/error`)
         visitExpression(statement.error.message, scope, `${statementPath}/error/message`)
+      } else if (statement.kind == "RethrowStatement") {
+        const symbol = scope.get(statement.binding)
+
+        if (symbol) reference(statement, symbol, "read", statementPath)
       } else if (statement.kind == "TryStatement") {
         visitBlock(statement.body, scope, `${statementPath}/body`)
-        visitType(statement.catchType, `${statementPath}/catchType`)
-        visitType(statement.catchBinding.type, `${statementPath}/catchBinding/type`)
-        const catchScope = new Map(scope)
-
-        catchScope.set(statement.catchBinding.name, declare(
-          statement.catchBinding,
-          statement.catchBinding.name,
-          "catch",
-          `${statementPath}/catchBinding`
-        ))
-        visitBlock(statement.catchBody, catchScope, `${statementPath}/catchBody`)
+        for (const [index, handler] of statement.handlers.entries()) {
+          const handlerPath = `${statementPath}/handlers/${index}`
+
+          visitType(handler.catchType, `${handlerPath}/catchType`)
+          visitType(handler.catchBinding.type, `${handlerPath}/catchBinding/type`)
+          const catchScope = new Map(scope)
+
+          catchScope.set(handler.catchBinding.name, declare(
+            handler.catchBinding,
+            handler.catchBinding.name,
+            "catch",
+            `${handlerPath}/catchBinding`
+          ))
+          visitBlock(handler.catchBody, catchScope, `${handlerPath}/catchBody`)
+        }
+        if (statement.finallyBody) visitBlock(statement.finallyBody, scope, `${statementPath}/finallyBody`)
       }
     }
   }
@@ -1005,7 +1020,7 @@ function resolveSymbols(module, records) {
 
   /**
    * Attaches one resolved symbol reference.
-   * @param {import("./types.js").IdentifierExpression | import("./types.js").ReceiverExpression | import("./types.js").CallExpression | import("./types.js").EffectCallExpression | import("./types.js").MethodCallExpression | import("./types.js").TypeVariableReference | import("./types.js").RecordType | import("./types.js").ReferenceType | import("./types.js").OwnedReferenceType | import("./types.js").OwnedResourceType | import("./types.js").RecordConstruction | import("./types.js").ReferenceConstruction | import("./types.js").MemberRead | import("./types.js").PrivateFieldRead | import("./types.js").PrivateFieldWriteStatement | import("./types.js").ErrorType | import("./types.js").ErrorConstruction} node - Reference node.
+   * @param {import("./types.js").IdentifierExpression | import("./types.js").ReceiverExpression | import("./types.js").CallExpression | import("./types.js").EffectCallExpression | import("./types.js").MethodCallExpression | import("./types.js").TypeVariableReference | import("./types.js").RecordType | import("./types.js").ReferenceType | import("./types.js").OwnedReferenceType | import("./types.js").OwnedResourceType | import("./types.js").RecordConstruction | import("./types.js").ReferenceConstruction | import("./types.js").MemberRead | import("./types.js").PrivateFieldRead | import("./types.js").PrivateFieldWriteStatement | import("./types.js").RethrowStatement | import("./types.js").ErrorType | import("./types.js").ErrorConstruction} node - Reference node.
    * @param {string | undefined} symbolId - Resolved symbol.
    * @param {"type" | "construct" | "member" | "read" | "write" | "call"} role - Reference role.
    * @param {string} path - Reference occurrence path.

package/src/semantic/types.js

@@ -1229,6 +1229,15 @@
  * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Parser-owned raise range.
  */
 
+/**
+ * @typedef RethrowStatement
+ * @property {"RethrowStatement"} kind - Re-propagation of the exact caught binding in scope.
+ * @property {string} binding - Name of the lexically visible immutable catch binding being re-raised.
+ * @property {CatchBinding} bindingNode - Exact catch binding node being re-raised.
+ * @property {SourceLocation} location - Complete rethrow source location.
+ * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Parser-owned rethrow range.
+ */
+
 /**
  * @typedef CatchBinding
  * @property {"CatchBinding"} kind - Exact-handler binding discriminator.
@@ -1240,18 +1249,27 @@
  */
 
 /**
- * @typedef TryStatement
- * @property {"TryStatement"} kind - One body and one exact typed handler.
- * @property {Block} body - Protected body.
+ * @typedef CatchHandler
+ * @property {"CatchHandler"} kind - One exact nominal handler within an ordered handler list.
  * @property {ErrorType} catchType - Exact caught nominal error type.
  * @property {CatchBinding} catchBinding - Immutable handler-local binding.
  * @property {Block} catchBody - Handler body.
+ * @property {SourceLocation} location - Complete handler source location.
+ * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Parser-owned catch ranges.
+ */
+
+/**
+ * @typedef TryStatement
+ * @property {"TryStatement"} kind - One body, an ordered list of exact typed handlers, and an optional completion block.
+ * @property {Block} body - Protected body.
+ * @property {CatchHandler[]} handlers - Ordered exact handlers, evaluated top to bottom with exact nominal matching.
+ * @property {Block} [finallyBody] - Completion block executed on every normal and abrupt completion of the try.
  * @property {SourceLocation} location - Complete try/handler source location.
- * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Parser-owned try/catch ranges.
+ * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Parser-owned try/catch/finally ranges.
  */
 
 /** @typedef {LocalDeclaration | AssignmentStatement} LocalStatement */
-/** @typedef {LocalStatement | PrivateFieldWriteStatement | ExpressionStatement | IfStatement | ForEachStatement | ForEachMapStatement | WhileStatement | BreakStatement | ContinueStatement | ReturnStatement | PrintStatement | RaiseStatement | TryStatement} Statement */
+/** @typedef {LocalStatement | PrivateFieldWriteStatement | ExpressionStatement | IfStatement | ForEachStatement | ForEachMapStatement | WhileStatement | BreakStatement | ContinueStatement | ReturnStatement | PrintStatement | RaiseStatement | RethrowStatement | TryStatement} Statement */
 
 /**
  * @typedef Block
@@ -1468,7 +1486,7 @@
  * @property {StdlibFacadeProgramDescriptor} [stdlibFacades] - Complete selected source-language facade closure.
  */
 
-/** @typedef {SemanticModule | SemanticProgramModule | SemanticImport | SemanticExport | RecordDeclaration | ClassDeclaration | ErrorDeclaration | EffectCapabilityDeclaration | EffectResourceDeclaration | EffectFailureDeclaration | EffectOperationDeclaration | RecordField | PrivateField | ConstructorDeclaration | MethodDeclaration | FunctionDeclaration | TypeParameter | Parameter | ValueBinding | CatchBinding | Block | Statement | EntryPoint | Expression | ErrorConstruction | ErrorType | MapEntry | SemanticValueType | FunctionReturnTypeReference} SemanticNode */
+/** @typedef {SemanticModule | SemanticProgramModule | SemanticImport | SemanticExport | RecordDeclaration | ClassDeclaration | ErrorDeclaration | EffectCapabilityDeclaration | EffectResourceDeclaration | EffectFailureDeclaration | EffectOperationDeclaration | RecordField | PrivateField | ConstructorDeclaration | MethodDeclaration | FunctionDeclaration | TypeParameter | Parameter | ValueBinding | CatchBinding | CatchHandler | Block | Statement | EntryPoint | Expression | ErrorConstruction | ErrorType | MapEntry | SemanticValueType | FunctionReturnTypeReference} SemanticNode */
 /** @typedef {SemanticNode} SemanticNodeWithoutLocations */
 
 export {}

package/src/semantic/validate.js

@@ -8,7 +8,7 @@ import {parserRangeFor} from "./provenance.js"
 import {validateEffectGraph} from "./effects.js"
 import {validateResourceLifetimes} from "./lifetime.js"
 
-const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "dart", "zig"])
+const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "c", "dart", "zig"])
 
 /** @typedef {Map<string, import("./types.js").RecordDeclaration>} RecordRegistry */
 /** @typedef {Map<string, import("./types.js").ClassDeclaration>} ClassRegistry */
@@ -160,7 +160,7 @@ function validateBlockShape(block, detail, fail) {
   }
 
   for (const statement of block.statements) {
-    if (!["AssignmentStatement", "BreakStatement", "ContinueStatement", "ExpressionStatement", "ForEachMapStatement", "ForEachStatement", "IfStatement", "LocalDeclaration", "PrivateFieldWriteStatement", "PrintStatement", "RaiseStatement", "ReturnStatement", "TryStatement", "WhileStatement"].includes(statement.kind)) {
+    if (!["AssignmentStatement", "BreakStatement", "ContinueStatement", "ExpressionStatement", "ForEachMapStatement", "ForEachStatement", "IfStatement", "LocalDeclaration", "PrivateFieldWriteStatement", "PrintStatement", "RaiseStatement", "RethrowStatement", "ReturnStatement", "TryStatement", "WhileStatement"].includes(statement.kind)) {
       fail(`${detail} statement ${statement.kind}`, statement.location)
     }
     if (statement.kind == "IfStatement") {
@@ -172,7 +172,18 @@ function validateBlockShape(block, detail, fail) {
     }
     if (statement.kind == "TryStatement") {
       validateBlockShape(statement.body, "try body", fail)
-      validateBlockShape(statement.catchBody, "catch body", fail)
+      if (!Array.isArray(statement.handlers) || (statement.handlers.length == 0 && !statement.finallyBody)) {
+        fail(`${detail} try without an ordered handler list`, statement.location)
+      }
+
+      for (const handler of statement.handlers ?? []) {
+        if (!handler || handler.kind != "CatchHandler" ||
+          Object.keys(handler).filter((key) => key != "sourceProvenance").sort().join(",") != "catchBinding,catchBody,catchType,kind,location") {
+          fail(`${detail} malformed catch handler`, handler?.location ?? statement.location)
+        }
+        validateBlockShape(handler.catchBody, "catch body", fail)
+      }
+      if (statement.finallyBody) validateBlockShape(statement.finallyBody, "finally body", fail)
     }
   }
 }
@@ -310,7 +321,8 @@ function prepareLoopIdentities(module, normalizeOperations, fail) {
         if (statement.alternate) visit(statement.alternate, owner, active)
       } else if (statement.kind == "TryStatement") {
         visit(statement.body, owner, active)
-        visit(statement.catchBody, owner, active)
+        for (const handler of statement.handlers ?? []) visit(handler.catchBody, owner, active)
+        if (statement.finallyBody) visit(statement.finallyBody, owner, active)
       }
     }
   }
@@ -1086,44 +1098,87 @@ function validateBlock(block, scope, returnType, functions, records, errors, cal
       normal = false
       continue
     }
-    if (statement.kind == "TryStatement") {
-      const caughtType = validateErrorType(statement.catchType, statement.location, errors, fail)
+    if (statement.kind == "RethrowStatement") {
+      const binding = findBinding(statement.binding, scope)
 
-      if (!statement.catchBinding || statement.catchBinding.kind != "CatchBinding" || statement.catchBinding.mutable !== false) {
-        fail("INVALID_ERROR_HANDLER", "Catch requires one immutable typed binding.", statement.catchBinding?.location ?? statement.location)
+      if (!binding || binding.mutable !== false || binding.type.kind != "ErrorType") {
+        fail("INVALID_RETHROW", "Rethrow requires a catch binding in scope.", statement.location)
       }
-      const bindingType = validateErrorType(statement.catchBinding.type, statement.catchBinding.location, errors, fail)
-
-      if (bindingType.declarationId != caughtType.declarationId) {
-        fail("INVALID_ERROR_HANDLER", "Catch binding type must exactly match its handler type.", statement.catchBinding.location)
+      raises.add(/** @type {import("./types.js").ErrorType} */ (binding.type).declarationId)
+      normal = false
+      continue
+    }
+    if (statement.kind == "TryStatement") {
+      if (!Array.isArray(statement.handlers) || (statement.handlers.length == 0 && !statement.finallyBody)) {
+        fail("INVALID_ERROR_HANDLER", "Try requires at least one exact typed handler or a finally block.", statement.location)
       }
       const bodyAssignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope)
       const assignedOuterBindings = new Set(bodyAssignedOuterBindings)
 
-      outerMutableBindingsAssignedBy(statement.catchBody, scope, assignedOuterBindings)
+      for (const handler of statement.handlers) outerMutableBindingsAssignedBy(handler.catchBody, scope, assignedOuterBindings)
+      if (statement.finallyBody) outerMutableBindingsAssignedBy(statement.finallyBody, scope, assignedOuterBindings)
       const bodyScope = createScope(scope, statement.body.statements)
       const bodyFlow = validateBlock(statement.body, bodyScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext)
-      const catchScope = createScope(scope, statement.catchBody.statements)
 
-      for (const binding of bodyAssignedOuterBindings) {
-        binding.knownValue = undefined
-        catchScope.presenceProofs.delete(binding)
-      }
+      let remainingRaises = new Set(bodyFlow.raises)
+      let normalCompletion = bodyFlow.normal
+      const handlerRaises = new Set()
+      const seenHandlerNames = new Set()
 
-      declareBinding(statement.catchBinding.name, {
-        knownValue: undefined,
-        mutable: false,
-        type: bindingType
-      }, roleLocation(statement.catchBinding, "name"), catchScope, fail)
-      const catchFlow = validateBlock(statement.catchBody, catchScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext)
+      for (const handler of statement.handlers) {
+        const caughtType = validateErrorType(handler.catchType, handler.location, errors, fail)
 
-      if (!bodyFlow.raises.has(caughtType.declarationId)) {
-        fail("UNREACHABLE_HANDLER", `Handler for '${errors.get(caughtType.declarationId)?.name}' cannot be reached.`, typeLocation(statement.catchType, statement.location))
+        if (!handler.catchBinding || handler.catchBinding.kind != "CatchBinding" || handler.catchBinding.mutable !== false) {
+          fail("INVALID_ERROR_HANDLER", "Catch requires one immutable typed binding.", handler.catchBinding?.location ?? handler.location)
+        }
+        const bindingType = validateErrorType(handler.catchBinding.type, handler.catchBinding.location, errors, fail)
+
+        if (bindingType.declarationId != caughtType.declarationId) {
+          fail("INVALID_ERROR_HANDLER", "Catch binding type must exactly match its handler type.", handler.catchBinding.location)
+        }
+        if (!remainingRaises.has(caughtType.declarationId)) {
+          fail("UNREACHABLE_HANDLER", `Handler for '${errors.get(caughtType.declarationId)?.name}' cannot be reached.`,
+            typeLocation(handler.catchType, handler.location))
+        }
+        if (seenHandlerNames.has(handler.catchBinding.name)) {
+          fail("DUPLICATE_BINDING", `Duplicate or shadowed binding '${handler.catchBinding.name}'.`, handler.catchBinding.location)
+        }
+        seenHandlerNames.add(handler.catchBinding.name)
+        remainingRaises.delete(caughtType.declarationId)
+        const catchScope = createScope(scope, handler.catchBody.statements)
+
+        for (const binding of bodyAssignedOuterBindings) {
+          binding.knownValue = undefined
+          catchScope.presenceProofs.delete(binding)
+        }
+        declareBinding(handler.catchBinding.name, {
+          knownValue: undefined,
+          mutable: false,
+          type: bindingType
+        }, roleLocation(handler.catchBinding, "name"), catchScope, fail)
+        const catchFlow = validateBlock(handler.catchBody, catchScope, returnType, functions, records, errors, callEffects, fail,
+          normalizeOperations, loopContext)
+
+        normalCompletion = normalCompletion || catchFlow.normal
+        addAll(handlerRaises, catchFlow.raises)
+      }
+      const pendingRaises = new Set(remainingRaises)
+
+      addAll(pendingRaises, handlerRaises)
+      if (statement.finallyBody) {
+        const finallyScope = createScope(scope, statement.finallyBody.statements)
+        const finallyFlow = validateBlock(statement.finallyBody, finallyScope, returnType, functions, records, errors, callEffects,
+          fail, normalizeOperations, loopContext)
+        // `raises` is the enclosing block's accumulator. A completion block replaces only this try's
+        // pending completion; escapes contributed by earlier statements of the enclosing block survive
+        // whichever way the completion block completes.
+        if (finallyFlow.normal) addAll(raises, pendingRaises)
+        addAll(raises, finallyFlow.raises)
+        normal = finallyFlow.normal ? normalCompletion : false
+      } else {
+        addAll(raises, pendingRaises)
+        normal = normalCompletion
       }
-      bodyFlow.raises.delete(caughtType.declarationId)
-      addAll(raises, bodyFlow.raises)
-      addAll(raises, catchFlow.raises)
-      normal = bodyFlow.normal || catchFlow.normal
       for (const binding of assignedOuterBindings) {
         binding.knownValue = undefined
         scope.presenceProofs.delete(binding)
@@ -1271,14 +1326,27 @@ function syntacticBlockEffects(block, callEffects, methodEffects = new Map()) {
       }
       continue
     }
+    if (kind == "RethrowStatement") {
+      const bindingNode = Reflect.get(statement, "bindingNode")
+      const bindingType = bindingNode && typeof bindingNode == "object" ? Reflect.get(bindingNode, "type") : undefined
+      const declarationId = bindingType && typeof bindingType == "object" ? Reflect.get(bindingType, "declarationId") : undefined
+
+      if (typeof declarationId == "string") result.add(declarationId)
+      continue
+    }
     if (kind == "TryStatement") {
-      const bodyEffects = syntacticBlockEffects(Reflect.get(statement, "body"), callEffects, methodEffects)
-      const catchType = Reflect.get(statement, "catchType")
-      const caughtId = catchType && typeof catchType == "object" ? Reflect.get(catchType, "declarationId") : undefined
+      let bodyEffects = syntacticBlockEffects(Reflect.get(statement, "body"), callEffects, methodEffects)
+
+      for (const handler of Reflect.get(statement, "handlers") ?? []) {
+        if (!handler || typeof handler != "object") continue
+        const catchType = Reflect.get(handler, "catchType")
+        const caughtId = catchType && typeof catchType == "object" ? Reflect.get(catchType, "declarationId") : undefined
 
-      if (typeof caughtId == "string" && bodyEffects.delete(caughtId)) {
-        addAll(bodyEffects, syntacticBlockEffects(Reflect.get(statement, "catchBody"), callEffects, methodEffects))
+        if (typeof caughtId == "string" && bodyEffects.delete(caughtId)) {
+          addAll(bodyEffects, syntacticBlockEffects(Reflect.get(handler, "catchBody"), callEffects, methodEffects))
+        }
       }
+      addAll(bodyEffects, syntacticBlockEffects(Reflect.get(statement, "finallyBody"), callEffects, methodEffects))
       addAll(result, bodyEffects)
       continue
     }
@@ -3046,7 +3114,8 @@ function outerMutableBindingsAssignedBy(block, outerScope, assigned = new Set())
       outerMutableBindingsAssignedBy(statement.body, outerScope, assigned)
     } else if (statement.kind == "TryStatement") {
       outerMutableBindingsAssignedBy(statement.body, outerScope, assigned)
-      outerMutableBindingsAssignedBy(statement.catchBody, outerScope, assigned)
+      for (const handler of statement.handlers ?? []) outerMutableBindingsAssignedBy(handler.catchBody, outerScope, assigned)
+      if (statement.finallyBody) outerMutableBindingsAssignedBy(statement.finallyBody, outerScope, assigned)
     }
   }