semantifold 0.11.0 → 0.13.0

package/src/backends/shared.js

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

package/src/backends/typescript.js

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

package/src/frontends/c.js

@@ -12,7 +12,7 @@ import {withAdaptedOperation} from "../semantic/operators.js"
 import {withParserRanges} from "../semantic/provenance.js"
 import {hasOnlyUnicodeScalars} from "../semantic/scalars.js"
 import {validateParsedModule} from "../semantic/validate.js"
-import {sourceScalarType} from "./scalars.js"
+import {sourceScalarType, requireSourceReturnType} from "./scalars.js"
 
 /** @typedef {import("./c-parser.js").CstNode} CstNode */
 /** @typedef {import("../semantic/types.js").Expression} Expression */
@@ -29,6 +29,15 @@ const helpers = new Map([
   ["semantifold_string_equal", "StringEqual"], ["semantifold_string_not_equal", "StringNotEqual"]
 ])
 
+/**
+ * Reads the exact scalar-or-void type name of a C declaration annotation.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType | import("../semantic/types.js").SemanticValueType} type - Converted C type.
+ * @returns {string} Type name.
+ */
+function returnTypeName(type) {
+  return type.kind == "TypeReference" ? type.name : type.kind
+}
+
 /** Strict field-and-token consumer for the private frozen C CST. */
 export class CReader {
   /**
@@ -48,7 +57,11 @@ export class CReader {
     /** @type {Map<Statement, {node: CstNode, type: string}>} */
     this.printTypes = new Map()
     /** @type {Set<string>} */
-    this.declaredFunctions = new Set()
+    this.declaredFunctionNames = new Set()
+    /** @type {{name: string, node: CstNode, parameterTypes: string[], returnType: string}[]} */
+    this.prototypes = []
+    /** @type {boolean} */
+    this.voidFunction = false
   }
 
   /**
@@ -303,10 +316,9 @@ export class CReader {
         if (call.arguments.length != 2) this.fail(node, "scalar helper arity")
         return this.binary(node, intent, this.expression(call.arguments[0], true), this.expression(call.arguments[1], true), call.name)
       }
-      if (call.arguments.length != 2) this.fail(node, "semantic call arity")
       const callee = this.identifier(call.name)
 
-      if (!this.generated && !this.declaredFunctions.has(callee)) this.fail(call.name, "implicit function declaration")
+      if (!this.generated && !this.declaredFunctionNames.has(callee)) this.fail(call.name, "implicit function declaration")
       return withParserRanges({kind: "CallExpression", location, callee,
         arguments: call.arguments.map((argument) => this.expression(argument, true))}, {callee: this.location(call.name)})
     }
@@ -369,6 +381,11 @@ export class CReader {
     if (node.type == "return_statement") {
       const parts = this.parts(node)
 
+      if (parts.length == 2) {
+        this.shape(node, ["return", ";"])
+        if (!this.voidFunction) this.fail(node, "bare return requires a void function")
+        return {kind: "ReturnStatement", location}
+      }
       this.shape(node, ["return", parts[1], ";"])
       return {kind: "ReturnStatement", location, expression: this.expression(parts[1])}
     }
@@ -403,13 +420,18 @@ export class CReader {
       }
       const call = this.call(expression)
 
-      if (!/^semantifold_print_(?:integer|boolean|string)$/u.test(this.text(call.name)) || call.arguments.length != 1) this.fail(node, "print scaffold")
-      const value = this.expression(call.arguments[0])
+      if (/^semantifold_print_(?:integer|boolean|string)$/u.test(this.text(call.name))) {
+        if (call.arguments.length != 1) this.fail(node, "print scaffold")
+        const value = this.expression(call.arguments[0])
 
-      const statement = {kind: /** @type {const} */ ("PrintStatement"), location, expression: value}
+        const statement = {kind: /** @type {const} */ ("PrintStatement"), location, expression: value}
 
-      this.printTypes.set(statement, {node: call.name, type: this.text(call.name).slice("semantifold_print_".length)})
-      return statement
+        this.printTypes.set(statement, {node: call.name, type: this.text(call.name).slice("semantifold_print_".length)})
+        return statement
+      }
+      return withParserRanges({kind: /** @type {const} */ ("ExpressionStatement"), location,
+        expression: /** @type {import("../semantic/types.js").CallExpression} */ (this.expression(expression))},
+      {operator: this.location(this.parts(node)[1])})
     }
     return this.fail(node)
   }
@@ -445,20 +467,98 @@ export class CReader {
     const parameters = this.field(declarator, "parameters")
 
     this.shape(declarator, [name, parameters])
-    const parts = this.parts(parameters)
+    const converted = this.parameterList(parameters)
+    const returnType = requireSourceReturnType("c", this.text(type), "function return", this.location(node), this.location(type))
+    const outerVoid = this.voidFunction
+
+    this.voidFunction = returnType.kind == "TypeReference" && returnType.name == "void"
+    const convertedBody = this.block(body)
+
+    this.voidFunction = outerVoid
+    return withParserRanges({kind: "FunctionDeclaration", location: this.location(node), name: this.identifier(name), parameters: converted,
+      returnType, body: convertedBody}, {name: this.location(name)})
+  }
 
-    this.shape(parameters, ["(", "parameter_declaration", ",", "parameter_declaration", ")"])
-    const converted = [parts[1], parts[3]].map((parameter) => {
+  /**
+   * Validates one exact required positional parameter list and converts it in source order.
+   * @param {CstNode} parameters - Parameter list node.
+   * @returns {import("../semantic/types.js").Parameter[]} Converted parameters.
+   */
+  parameterList(parameters) {
+    const parts = this.parts(parameters)
+    const declarations = parts.slice(1, -1).filter((_part, index) => index % 2 == 0)
+    const voidOnly = declarations.length == 1 && parts.length == 3 && declarations[0].type == "parameter_declaration" &&
+      !declarations[0].children.some(({field}) => field == "declarator")
+
+    if (voidOnly) {
+      this.shape(parameters, ["(", "parameter_declaration", ")"])
+      if (this.text(declarations[0]) != "void") this.fail(declarations[0], "empty parameter list requires explicit void")
+      return []
+    }
+    if (declarations.length == 0) this.fail(parameters, "empty parameter list requires explicit void")
+    this.shape(parameters, ["(", ...declarations.flatMap((parameter, index) => index == 0 ? [parameter] : [",", parameter]), ")"])
+    return declarations.map((parameter) => {
       const typeNode = this.field(parameter, "type")
       const nameNode = this.field(parameter, "declarator")
 
       this.shape(parameter, [typeNode, nameNode])
       return withParserRanges({kind: /** @type {const} */ ("Parameter"), location: this.location(parameter), name: this.identifier(nameNode), type: this.type(typeNode)}, {name: this.location(nameNode)})
     })
+  }
 
-    this.declaredFunctions.add(this.identifier(name))
-    return withParserRanges({kind: "FunctionDeclaration", location: this.location(node), name: this.identifier(name), parameters: converted,
-      returnType: this.type(type), body: this.block(body)}, {name: this.location(name)})
+  /**
+   * Recognizes a file-local function prototype declaration without descending further.
+   * @param {CstNode} node - Candidate translation-unit member.
+   * @returns {boolean} Whether this is a function prototype.
+   */
+  isPrototype(node) {
+    if (node.type != "declaration") return false
+    const declarator = node.children.find(({field}) => field == "declarator")?.node
+
+    return declarator?.type == "function_declarator"
+  }
+
+  /**
+   * Records one exact static prototype signature before any body conversion.
+   * @param {CstNode} node - Prototype declaration.
+   * @returns {void}
+   */
+  recordPrototype(node) {
+    const type = this.field(node, "type")
+    const declarator = this.field(node, "declarator")
+
+    this.shape(node, ["storage_class_specifier", type, declarator, ";"])
+    if (this.text(this.parts(node)[0]) != "static" || declarator.type != "function_declarator") this.fail(node, "file-local prototype required")
+    const name = this.field(declarator, "declarator")
+    const parameters = this.field(declarator, "parameters")
+
+    this.shape(declarator, [name, parameters])
+    const converted = this.parameterList(parameters)
+    const nameText = this.identifier(name)
+
+    this.declaredFunctionNames.add(nameText)
+    this.prototypes.push({name: nameText, node,
+      parameterTypes: converted.map((parameter) => /** @type {import("../semantic/types.js").TypeReference} */ (parameter.type).name),
+      returnType: /** @type {import("../semantic/types.js").TypeReference} */ (requireSourceReturnType("c", this.text(type), "prototype return", this.location(node), this.location(type))).name})
+  }
+
+  /**
+   * Confirms every recorded prototype agrees with its unique function definition.
+   * @param {import("../semantic/types.js").FunctionDeclaration[]} functions - Converted definitions.
+   * @returns {void}
+   */
+  validatePrototypes(functions) {
+    const definitions = new Map(functions.map((declaration) => [declaration.name, declaration]))
+
+    for (const prototype of this.prototypes) {
+      const definition = definitions.get(prototype.name)
+
+      if (!definition) this.fail(prototype.node, "prototype without definition")
+      if (returnTypeName(definition.returnType) != prototype.returnType || definition.parameters.length != prototype.parameterTypes.length ||
+        definition.parameters.some((parameter, index) => returnTypeName(parameter.type) != prototype.parameterTypes[index])) {
+        this.fail(prototype.node, "prototype conflicts with function definition")
+      }
+    }
   }
 
   /**
@@ -511,17 +611,33 @@ export class CReader {
     if (!this.generated) this.rejectScaffoldComments(root)
     if (root.type != "translation_unit") this.fail(root, "translation unit required")
     const parts = this.parts(root)
-    const definitions = parts.slice(1).filter((node) => !this.generated || node.type != "declaration")
+    const members = parts.slice(1).filter((node) => !this.generated || node.type == "function_definition" || this.isPrototype(node))
 
-    if (parts.length < 3 || parts[0].type != "preproc_include" || definitions.some((node) => node.type != "function_definition")) this.fail(root, "translation unit members")
+    if (parts.length < 3 || parts[0].type != "preproc_include" ||
+      members.some((node) => node.type != "function_definition" && !this.isPrototype(node))) this.fail(root, "translation unit members")
     const include = parts[0]
     const header = this.field(include, "path")
 
     this.shape(include, ["#include", header])
     if (header.type != "string_literal" || this.text(header) != '"semantifold_runtime.h"') this.fail(include, "support header include")
+    const definitions = members.filter((node) => node.type == "function_definition")
+
     if (definitions.length < 2) this.fail(root, "semantic function and main required")
-    const module = {kind: /** @type {const} */ ("Module"), location: this.location(root), functions: definitions.slice(0, -1).map((node) => this.function(node)),
-      entryPoint: this.main(definitions[definitions.length - 1])}
+    const mainNode = definitions[definitions.length - 1]
+    const functions = []
+
+    for (const node of members) {
+      if (node === mainNode) continue
+      if (node.type != "function_definition") {
+        this.recordPrototype(node)
+        continue
+      }
+      this.declaredFunctionNames.add(this.identifier(this.field(this.field(node, "declarator"), "declarator")))
+      functions.push(this.function(node))
+    }
+    this.validatePrototypes(functions)
+    const module = {kind: /** @type {const} */ ("Module"), location: this.location(root), functions,
+      entryPoint: this.main(mainNode)}
 
     if (this.generated) validateNativeGraph(module)
     const validated = validateParsedModule(module, "c")