semantifold 0.11.0 → 0.12.0

package/docs/c.md

@@ -28,7 +28,7 @@ Canonical `main` calls `semantifold_cleanup()` once after semantic entry stateme
 
 The unchanged root-bundled private legacy boundary supplies recursively frozen C CST data from exact `tree-sitter@0.21.1` and `tree-sitter-c@0.23.2`. `src/frontends/c-parser.js` describes that private plain-data boundary; native handles and parser-specific objects never enter semantic values. Every child, field, anonymous token, extra, error, missing node and recovery flag is traversed before meaning is returned. Coordinates and token origins refer to the original UTF-16 source, including astral characters and CRLF. There is no parser-source scan, compiler-based interpretation, preprocessing fallback or source-text recovery.
 
-Ordinary source contains the exact support-header include, at least one `static` semantic function with two named explicitly typed parameters, and final `int main(void)`. Functions return exact scalars. Bodies admit initialized single scalar locals, plain assignment, prints through the matching scalar helper, explicit returns and braced conditionals, including `else if`. `const` locals are immutable; other locals are mutable, and parameters are immutable. Main ends with the exact cleanup call and `return 0`. Raw calls must refer to a preceding or current function definition. Caller-authored forward calls requiring implicit C declarations are rejected; canonical generated prototypes support forward calls and recursion.
+Ordinary source contains the exact support-header include, at least one `static` semantic function plus final `int main(void)`. Task 005 semantic functions accept any number of explicitly typed named parameters, including zero — spelled `void` for an empty list — and return exact scalars or `void`. A file-scope `static` prototype may precede a function definition for forward and mutual recursion; every prototype must agree exactly with its unique definition, and a prototype without a definition is rejected. Bodies admit initialized single scalar locals, plain assignment, prints through the matching scalar helper, explicit returns and braced conditionals, including `else if`. A non-void function returns a value on every reachable path; a void function may fall through or use a bare `return;`, and a bare return in a non-void function is rejected. A void call is legal only as a standalone statement. `const` locals are immutable; other locals are mutable, and parameters are immutable. Main ends with the exact cleanup call and `return 0`. Raw calls must refer to a preceding function definition or prototype; caller-authored forward calls requiring implicit C declarations are rejected, and canonical generated prototypes support forward calls and recursion.
 
 Only direct semantic calls and the exact scalar/literal/print helpers are recognized. Caller-authored calls nested in an operator operand or another call's argument are rejected because ordinary C does not establish the required semantic evaluation order. Trigraph preprocessing in parser-backed comments or string content is rejected. No user preprocessing, typedef substitution, global data, complex/multiple declarator, qualifier beyond local `const`, array, struct, union, enum, pointer, function pointer, cast, address/dereference, member access, ownership call, `sizeof`, comma/ternary, loop, switch, goto, update, compound operator, conversion or arbitrary external call is accepted.
 

package/docs/language-support.md

@@ -84,7 +84,7 @@ The shared negative corpus covers parser recovery, missing types, truthiness, mi
 
 ## Task 005 general functions and calls
 
-PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Dart, and Zig accept any number of required positional parameters, including zero. The module resolver collects every unique function signature before validating bodies, assigns declarations deterministic `function:N` identities, and binds each direct call to that identity plus its ordered parameter and return types. This permits forward calls, nested calls, direct recursion, and unambiguous mutual recursion without overload or dynamic dispatch. Arity and every positional scalar type must match exactly.
+PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, C, Dart, and Zig accept any number of required positional parameters, including zero. The module resolver collects every unique function signature before validating bodies, assigns declarations deterministic `function:N` identities, and binds each direct call to that identity plus its ordered parameter and return types. This permits forward calls, nested calls, direct recursion, and unambiguous mutual recursion without overload or dynamic dispatch. Arity and every positional scalar type must match exactly.
 
 Function returns are `integer`, `boolean`, `string`, or `void`. A non-void function has an expression on every reachable return and returns on every reachable path. A void function may fall through or use a bare return, and its call is legal only as an `ExpressionStatement`. Void is never a value: it cannot type a parameter or local, initialize or assign a binding, become an argument or operand, be printed, or be returned as a value. Generation revalidates declaration identities and complete resolved signatures in externally supplied IR. Function names, parameters, return annotations, callees, arguments, and resolution references retain deterministic parser-backed provenance and mappings.
 
@@ -94,10 +94,11 @@ The source profiles remain deliberately exact:
 - JavaScript accepts only declarations spelled `function name(...)` with a JSDoc annotation for every identifier parameter and an explicit scalar or `void` return annotation. TypeScript requires the corresponding explicit keyword annotations. Both reject optional/default/rest/destructured parameters, overloads, async/generators, arrows/function expressions, methods, callbacks and higher-order callees, optional/receiver/spread calls, and general TypeScript assertions. Task 012 adds only its exact generic declaration/application profile; Task 006 has one type-only exception for the exact independently validated `Map#get(...)!` round-trip form.
 - PHP accepts simple typed by-value required parameters, an explicit scalar or `void` return, and unqualified direct calls. Defaults, variadics, named/unpacked/by-reference arguments, by-reference parameters or returns, methods, dynamic/qualified calls, implicit nullability, and missing types are rejected; Task 007 adds only its exact explicit nullable profile.
 - Java accepts the established private-static semantic method profile with explicit supported parameter and scalar-or-void result types inside `public final class Main`, plus receiver-free direct calls and the exact entry method. Generated zero-parameter signatures named `getClass`, `hashCode`, `clone`, `toString`, `notify`, `notifyAll`, `wait`, or `finalize` conflict with inherited `java.lang.Object` instance methods and are rejected before emission; nonconflicting scalar-parameter overloads of those names remain available. Overload sets, instance/receiver/qualified/static-import ambiguity, varargs, bounded/defaulted/wildcard/raw generics, constructors, throws clauses, and non-static semantic methods are rejected.
+- C accepts file-scope `static` semantic functions with any number of explicitly typed named parameters — spelled `void` for an empty list — exact scalar or `void` returns, and unqualified direct calls. A `static` prototype may precede a definition for forward or mutual recursion and must agree exactly with its unique definition; a prototype without a definition, a conflicting prototype, an implicit declaration, a bare return in a non-void function, or `void` used as a parameter, local, argument, operand or printed value is rejected. Generated zero-parameter signatures spell `(void)` and generated prototypes make forward calls and recursion compilable under `-Wstrict-prototypes`/`-Wmissing-prototypes`. See [C source and target](c.md).
 - Dart accepts synchronous top-level functions with exact explicit `int`, `bool`, `String`, or `void` returns, explicitly typed required positional parameters, initialized typed locals, direct calls, and exact `void main()`/`print`. Inference, `var`, inferred `final`, optional/named/default arguments, methods/classes, generics, imports, dynamic/nullability, collections, exceptions, async, and isolates are rejected. Generated Dart alone may contain formatter-added trailing commas and the complete canonical private runtime prefix; neither grants those forms to ordinary source. See [Dart source and target](dart.md).
 - Zig accepts top-level functions with exact explicit `i64`, `bool`, `[]const u8`, or `void` returns, explicitly typed required positional parameters, initialized typed `const`/`var` locals, direct calls, and the exact generated support/`pub fn main()` shell. Inference, optional/default/rest parameters, methods, containers, user slices/pointers/allocators, imports beyond the canonical standard-library support, error unions, `comptime`, generics, reflection, FFI, async, and concurrency are rejected. See [Zig source and target](zig.md).
 
-Python, C#, C, C++, Rust, Swift, Kotlin/JVM, Go, and browser Wasm remain on their Task 025 Tasks 001–004 profile. Their registry feature flag is false, their existing exact-two/scalar-return behavior is unchanged, and a Task-005-only arity, void return, or void call statement is a located `UNSUPPORTED_CAPABILITY` before source, bytes, or a partial artifact set is exposed. This boundary does not broaden the future Task 013 aggregate acceptance.
+Python, C#, C++, Rust, Swift, Kotlin/JVM, Go, and browser Wasm remain on their Task 025 Tasks 001–004 profile. Their registry feature flag is false, their existing exact-two/scalar-return behavior is unchanged, and a Task-005-only arity, void return, or void call statement is a located `UNSUPPORTED_CAPABILITY` before source, bytes, or a partial artifact set is exposed. This boundary does not broaden the future Task 013 aggregate acceptance.
 
 ## Task 006 immutable lists and maps
 

package/docs/testing.md

@@ -36,7 +36,7 @@ These tests generate and publish source artifacts only. They do not run `javac`,
 
 ## Task 005 general function signatures and calls
 
-Task 005 stays bounded to PHP, Ruby, JavaScript with JSDoc, TypeScript, and Java. `general-function-signatures-and-calls.spec.js` proves equivalent zero-, one-, and three-parameter signatures, complete signature collection, nested calls, terminating recursion, scalar/void returns, and the stable semantic failures. `general-function-frontend-validation.spec.js` owns the excluded parameter, call, method, receiver, dispatch, annotation, overload, generic, and higher-order source forms. `general-function-backend-validation.spec.js` proves generation/reparse, exact external-IR signature revalidation, target conflicts, the public feature flag, and transactional rejection from every deferred Task 025/Wasm target. `general-function-provenance-and-mapping.spec.js` proves deterministic declaration/resolution identities and exact signature/call mappings. `general-function-runtime-execution.spec.js` invokes real PHP, Ruby, Node, local `tsc` followed by Node, `javac`, and `java`, requiring exact `ready\n6\n` output; a missing command fails.
+Task 005 stays bounded to PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Dart, Zig, and C. `general-function-signatures-and-calls.spec.js` proves equivalent zero-, one-, and three-parameter signatures, complete signature collection, nested calls, terminating recursion, scalar/void returns, and the stable semantic failures. `general-function-frontend-validation.spec.js` owns the excluded parameter, call, method, receiver, dispatch, annotation, overload, generic, and higher-order source forms. `general-function-backend-validation.spec.js` proves generation/reparse, exact external-IR signature revalidation, target conflicts, the public feature flag, and transactional rejection from every deferred Task 025/Wasm target. `general-function-provenance-and-mapping.spec.js` proves deterministic declaration/resolution identities and exact signature/call mappings. `general-function-runtime-execution.spec.js` invokes real PHP, Ruby, Node, local `tsc` followed by Node, `javac`, and `java`, requiring exact `ready\n6\n` output; a missing command fails. `c-task005-acceptance.spec.js` proves the C cohort extension: generated-C reparse with identical meaning, the C fixture through every original-five text target, and real Clang execution of each original-five Task-005 fixture and the C fixture at `-O0`/`-O2` with and without sanitizers, including prototype-mediated mutual recursion and bare void returns.
 
 Run the Task 005 files individually and sequentially:
 
@@ -46,9 +46,10 @@ npx velocious-test spec/general-function-frontend-validation.spec.js
 npx velocious-test spec/general-function-backend-validation.spec.js
 npx velocious-test spec/general-function-provenance-and-mapping.spec.js
 npx velocious-test spec/general-function-runtime-execution.spec.js
+npx velocious-test spec/c-task005-acceptance.spec.js
 ```
 
-Task 013 is the separate terminal original-five aggregate gate. Task 005 does not expand that matrix or adopt Python, C#, C, C++, Rust, Swift, Kotlin/JVM, Go, or browser Wasm beyond focused capability rejection.
+Task 013 is the separate terminal original-five aggregate gate. Task 005 does not expand that matrix or adopt Python, C#, C++, Rust, Swift, Kotlin/JVM, Go, or browser Wasm beyond focused capability rejection.
 
 ## Task 011 typed errors and handling
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantifold",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Language-neutral semantic code analysis, transformation, generation, and execution toolkit",
   "type": "module",
   "main": "build/index.js",

package/src/backends/c.js

@@ -16,7 +16,7 @@ import {SourceWriter} from "./writer.js"
 /** @typedef {import("../semantic/types.js").Block} Block */
 /** @typedef {import("./ordered-expressions.js").PlannedValue} PlannedValue */
 /** @typedef {import("./ordered-expressions.js").PlannedStep} PlannedStep */
-/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+/** @typedef {{id: string, steps: PlannedStep[], value?: PlannedValue, terminal?: PlannedStep}} StatementPlan */
 
 const binaryTokens = new Map([
   ["IntegerAdd", "semantifold_integer_add"], ["IntegerSubtract", "semantifold_integer_subtract"],
@@ -125,7 +125,7 @@ class CEmitter {
     module.functions.forEach((declaration, index) => {
       const parameters = declaration.parameters.map((parameter) => `${emitScalarType("c", parameter.type)} ${parameter.name}`).join(", ")
 
-      this.synthetic(`static ${emitScalarType("c", declaration.returnType)} ${declaration.name}(${parameters});\n`, declaration, `/functions/${index}`)
+      this.synthetic(`static ${emitScalarType("c", declaration.returnType)} ${declaration.name}(${declaration.parameters.length ? parameters : "void"});\n`, declaration, `/functions/${index}`)
     })
     module.functions.forEach((declaration, index) => {
       const path = `/functions/${index}`
@@ -135,6 +135,7 @@ class CEmitter {
       this.synthetic(" ", declaration, path)
       this.mapped(declaration.name, declaration, path, "name")
       this.synthetic("(", declaration, path)
+      if (!declaration.parameters.length) this.synthetic("void", declaration, path)
       declaration.parameters.forEach((parameter, parameterIndex) => {
         const parameterPath = `${path}/parameters/${parameterIndex}`
 
@@ -181,7 +182,25 @@ class CEmitter {
 
     this.synthetic(`${indent}/* ${marker} begin ${plan.id} ${signature} */\n`, statement, path)
     this.steps(plan.steps, indent)
+    if (statement.kind == "ReturnStatement" && !statement.expression) {
+      this.synthetic(indent, statement, path)
+      this.mapped("return", statement, path)
+      this.synthetic(";\n", statement, path)
+      this.synthetic(`${indent}/* ${marker} end ${plan.id} ${signature} */\n`, statement, path)
+      return
+    }
+    if (statement.kind == "ExpressionStatement") {
+      if (!plan.terminal) throw new Error("Missing validated C terminal call.")
+      this.synthetic(indent, statement, path)
+      this.operation(plan.terminal)
+      this.synthetic(";\n", statement, path)
+      this.synthetic(`${indent}/* ${marker} end ${plan.id} ${signature} */\n`, statement, path)
+      return
+    }
     this.synthetic(indent, statement, path)
+    const value = plan.value
+
+    if (!value) throw new Error("Missing validated C statement value plan.")
     if (statement.kind == "LocalDeclaration") {
       if (!statement.mutable) this.synthetic("const ", statement, path)
       this.mapped(emitScalarType("c", statement.type), statement.type, `${path}/type`, "type")
@@ -196,9 +215,9 @@ class CEmitter {
       this.mapped("=", statement, path, "operator")
       this.synthetic(" ", statement, path)
     } else if (statement.kind == "ReturnStatement") this.mapped("return ", statement, path)
-    else if (statement.kind == "PrintStatement") this.mapped(`semantifold_print_${plan.value.type}(`, statement, path)
+    else if (statement.kind == "PrintStatement") this.mapped(`semantifold_print_${value.type}(`, statement, path)
     else this.mapped("if (", statement, path)
-    this.value(plan.value)
+    this.value(value)
     if (statement.kind == "IfStatement") {
       this.synthetic(") {\n", statement, path)
       this.block(statement.consequent, `${path}/consequent`, `${indent}    `)

package/src/backends/cpp.js

@@ -153,6 +153,7 @@ class CppEmitter {
     const plan = this.plans.get(path)
 
     if (!plan) throw new Error("Missing validated C++ statement plan.")
+    if (!plan.value) throw new Error("Missing validated C++ statement value plan.")
     const marker = `semantifold:ordered-expression:cpp:v1`
     const signature = statementSignature(statement)
 

package/src/backends/ordered-expressions.js

@@ -5,7 +5,8 @@ import {unsupportedCapability} from "../diagnostic.js"
 
 /** @typedef {import("../semantic/types.js").Expression} Expression */
 /** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
-/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} PlannedValue */
+/** @typedef {Scalar | "void"} PlannedType */
+/** @typedef {{expression: Expression, path: string, type: PlannedType, name?: string}} PlannedValue */
 /** @typedef {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */
 /** @typedef {Array<string | number | boolean | Signature>} Signature */
 
@@ -20,7 +21,7 @@ export class OrderedExpressionPlanner {
     this.language = language
     this.functions = new Map(module.functions.map((declaration) => [
       declaration.name,
-      scalarName(declaration.returnType, language, declaration.location)
+      returnName(declaration.returnType, language, declaration.location)
     ]))
     this.nextTemporary = 1
   }
@@ -29,7 +30,7 @@ export class OrderedExpressionPlanner {
    * Resolves an expression type from the validated lexical environment.
    * @param {Expression} expression - Semantic expression.
    * @param {Map<string, Scalar>} bindings - Lexical scalar types.
-   * @returns {Scalar} Exact semantic result type.
+   * @returns {PlannedType} Exact semantic result type.
    */
   type(expression, bindings) {
     if (expression.kind == "IntegerLiteral") return "integer"
@@ -76,12 +77,31 @@ export class OrderedExpressionPlanner {
       }
       operands.push(this.plan(expression.right, `${path}/right`, bindings, steps))
     }
+    if (result.type == "void") throw new Error("Void call reached native value planning.")
     const planned = {...result, name: this.allocate(expression)}
 
     steps.push({operands, result: planned})
     return planned
   }
 
+  /**
+   * Plans the arguments of one terminal void call without inventing a void temporary.
+   * @param {Expression} expression - Terminal expression occurrence.
+   * @param {string} path - Occurrence path.
+   * @param {Map<string, Scalar>} bindings - Visible scalar bindings.
+   * @param {PlannedStep[]} steps - Ordered enclosing prelude.
+   * @returns {PlannedStep} Terminal direct-call step.
+   */
+  terminal(expression, path, bindings, steps) {
+    if (expression.kind != "CallExpression" || this.type(expression, bindings) != "void") {
+      throw new Error("Non-void expression reached native terminal-call planning.")
+    }
+    const result = {expression, path, type: /** @type {const} */ ("void")}
+    const operands = expression.arguments.map((argument, index) => this.plan(argument, `${path}/arguments/${index}`, bindings, steps))
+
+    return {operands, result}
+  }
+
   /**
    * Allocates one bounded deterministic occurrence name.
    * @param {Expression} expression - Related expression.
@@ -108,9 +128,9 @@ export function statementSignature(statement) {
       statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? statement.expression :
         statement.kind == "ReturnStatement" ? statement.expression : undefined
 
-  if (!expression) throw new TypeError("Bare return reached native statement signature planning.")
+  if (!expression && statement.kind != "ReturnStatement") throw new TypeError("Bare return reached native statement signature planning.")
 
-  return createHash("sha256").update(JSON.stringify([consumer, expressionSignature(expression)])).digest("hex")
+  return createHash("sha256").update(JSON.stringify([consumer, expression ? expressionSignature(expression) : null])).digest("hex")
 }
 
 /**
@@ -128,7 +148,7 @@ function expressionSignature(expression) {
   return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)]
 }
 
-/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+/** @typedef {{id: string, steps: PlannedStep[], value?: PlannedValue, terminal?: PlannedStep}} StatementPlan */
 /**
  * Plans every occurrence before constructing a writer or exposing either artifact.
  * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
@@ -159,12 +179,13 @@ export function planNativeModule(module, language = "c") {
             statement.kind == "ReturnStatement" ? statement.expression : undefined
       /** @type {PlannedStep[]} */
       const steps = []
-
-      if (!expression) throw new TypeError("Bare return reached native expression planning.")
-      const value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)
+      /** @type {StatementPlan} */
+      const plan = {id: String(plans.size + 1).padStart(6, "0"), steps}
 
       if (plans.size >= 999999) unsupportedCapability(language, "ordered statement limit", statement.location)
-      plans.set(statementPath, {id: String(plans.size + 1).padStart(6, "0"), steps, value})
+      if (statement.kind == "ExpressionStatement") plan.terminal = planner.terminal(statement.expression, `${statementPath}/${field}`, bindings, steps)
+      else if (expression) plan.value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)
+      plans.set(statementPath, plan)
       if (statement.kind == "LocalDeclaration") bindings.set(statement.name, scalarName(statement.type, language, statement.location))
       if (statement.kind == "IfStatement") {
         visit(statement.consequent, `${statementPath}/consequent`, bindings)
@@ -193,3 +214,18 @@ function scalarName(type, language, location) {
 
   return type.name
 }
+
+/**
+ * Narrows a validated function return, admitting the non-value `void` result.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {"c" | "cpp"} language - Diagnostic language.
+ * @param {import("../semantic/types.js").SourceLocation} location - Owning location.
+ * @returns {PlannedType} Scalar or void name.
+ */
+function returnName(type, language, location) {
+  if (type.kind != "TypeReference") {
+    return unsupportedCapability(language, "collection type reached native scalar planning", location)
+  }
+
+  return type.name
+}

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"])

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")

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/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 */