semantifold 0.10.0 → 0.12.0

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
 
@@ -380,7 +381,7 @@ Task 017 adds the distinct ordered `restore` stage and configured .NET SDK 10 di
 
 Task 024 adds configured Go 1.26.x discovery restricted to Linux/amd64; the patch release is read from the discovered toolchain rather than fixed by runtime tests. Acceptance obtains `GOROOT` from that exact `go`, requires the companion `gofmt` beside the configured or discovered executable to resolve to the same `GOROOT/bin/gofmt`, and checks `gofmt -d` before native execution. Each dependency-free generated module is run with `GOTOOLCHAIN=local`, `GOPROXY=off`, `GOSUMDB=off`, `GOVCS=off`, `CGO_ENABLED=0`, `GOENV=off`, `GOWORK=off`, `GOOS=linux`, `GOARCH=amd64`, and isolated HOME/GOPATH/build/module caches. The short-lived discovery fixture also writes exact `off` mode into its isolated Go telemetry directory before invoking the tool, then asserts that the mode file is the only telemetry state: Go 1.26 otherwise starts an unawaited uploader sidecar even in default `local` mode, which can recreate `upload/` while the fixture root is being removed. Cleanup errors remain fatal. Stages run offline `go build`, mandatory `go vet`, and `go run`, while compiler-only differential cases use the matching `go tool compile`. Tests require exact status/stdout, unchanged `go.mod`/`main.go`, no `go.sum`/`go.work`/vendor tree, and byte-identical binaries and output in two fresh directories. Missing, wrong-minor, wrong-architecture, mismatched-gofmt, download, cgo, workspace, vet, formatting, nondeterminism, telemetry leakage, or cleanup evidence fails without a skip.
 
-Task 023 adds exact Kotlin/JVM 2.4.20 discovery on pinned OpenJDK 25 Ubuntu runtimes. Ubuntu26.04 development uses exact `25.0.4.1+1-1~26.04.4`; Ubuntu24.04 TensorBuzz retains exact `25.0.4+7-1~24.04`. Bootstrap and discovery accept only those two qualified compiler-reported package identities, never arbitrary output. Original and generated `Program.kt` files compile with `-language-version 2.4 -api-version 2.4 -jvm-target 25 -Werror -include-runtime` into runnable `Program.jar` files, then execute through the exact `java25` discovery contract. Every process uses a fresh directory and exact status/stderr/UTF-8 stdout assertions; no test downloads a compiler or dependency.
+Task 023 adds exact Kotlin/JVM 2.4.20 discovery on pinned OpenJDK 25 Ubuntu runtimes. Ubuntu26.04 development uses exact `25.0.4.1+1-1~26.04.4`; Ubuntu24.04 TensorBuzz uses exact `25.0.4.1+1-1~24.04.4`. Bootstrap and discovery accept only those two qualified compiler-reported package identities, never arbitrary output. Original and generated `Program.kt` files compile with `-language-version 2.4 -api-version 2.4 -jvm-target 25 -Werror -include-runtime` into runnable `Program.jar` files, then execute through the exact `java25` discovery contract. Every process uses a fresh directory and exact status/stderr/UTF-8 stdout assertions; no test downloads a compiler or dependency.
 
 Task 041's product checks are separate from runtime acceptance. Run the two focused files sequentially:
 
@@ -424,7 +425,7 @@ No Task 042 plan runs a generated executable, fetches a package, consults a user
 | `tsc` | `tsc` | `SEMANTIFOLD_TSC` | TypeScript 7.x |
 | `javac` | `javac` | `SEMANTIFOLD_JAVAC` | JDK 17–29 |
 | `java` | `java` | `SEMANTIFOLD_JAVA` | JRE 17–29 |
-| `java25` | `java` | `SEMANTIFOLD_JAVA` | exact OpenJDK 25.0.4.1+1 development or 25.0.4+7 TensorBuzz runtime for JVM25 artifacts |
+| `java25` | `java` | `SEMANTIFOLD_JAVA` | exact OpenJDK 25.0.4.1+1 development or TensorBuzz runtime for JVM25 artifacts |
 | `kotlinc` | `kotlinc` | `SEMANTIFOLD_KOTLINC` | exact Kotlin/JVM 2.4.20 on the matching qualified OpenJDK 25 Ubuntu package |
 | `python` | `python3` | `SEMANTIFOLD_PYTHON` | Python 3.x |
 | `dotnet` | `dotnet` | `SEMANTIFOLD_DOTNET` | .NET SDK 10.x |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantifold",
-  "version": "0.10.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/kotlin.js

@@ -15,7 +15,7 @@ export const kotlinArtifactMetadata = Object.freeze({
     toolchain: "kotlinc",
     version: "2.4.20"
   }),
-  run: Object.freeze({arguments: Object.freeze(["-jar", "Program.jar"]), toolchain: "java25", version: "25.0.4+7"})
+  run: Object.freeze({arguments: Object.freeze(["-jar", "Program.jar"]), toolchain: "java25", version: "25.0.4.1"})
 })
 
 /**

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"])
@@ -37,6 +37,7 @@ const task012Languages = new Set(["php", "ruby", "javascript", "typescript", "ja
 const task014Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task032Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task033Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
+const task048ConditionalLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const javaReferenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait"])
 const javascriptReferenceMethodHooks = new Set([
   "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor",
@@ -1129,6 +1130,11 @@ function expressionContainsKind(expression, kind) {
   if (expression.kind == "BinaryExpression") {
     return expressionContainsKind(expression.left, kind) || expressionContainsKind(expression.right, kind)
   }
+  if (expression.kind == "ConditionalExpression") {
+    return expressionContainsKind(expression.condition, kind) ||
+      expressionContainsKind(expression.consequent, kind) ||
+      expressionContainsKind(expression.alternate, kind)
+  }
   if (expression.kind == "CallExpression") return expression.arguments.some((argument) => expressionContainsKind(argument, kind))
   if (expression.kind == "MethodCallExpression") {
     return expressionContainsKind(expression.receiver, kind) ||
@@ -1936,6 +1942,19 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
     return
   }
 
+  if (candidate.kind == "ConditionalExpression") {
+    const fields = Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",")
+
+    if (fields != "alternate,condition,consequent,kind,location,type") {
+      unsupportedCapability(language, "malformed ConditionalExpression", location)
+    }
+    if (!task048ConditionalLanguages.has(language)) unsupportedCapability(language, "Task 048 conditional expression", location)
+    validateExpression(candidate.condition, language, location, false, expressionPath, externalDeclarationIds)
+    validateExpression(candidate.consequent, language, location, false, expressionPath, externalDeclarationIds)
+    validateExpression(candidate.alternate, language, location, false, expressionPath, externalDeclarationIds)
+    return
+  }
+
   unsupportedCapability(language, String(Reflect.get(expression, "kind")), location)
 }
 
@@ -2364,6 +2383,17 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
 
+  if (expression.kind == "ConditionalExpression") {
+    writer.mapped("(", {mappingKind: "anchor", node: expression, path})
+    emitExpression(writer, expression.condition, `${path}/condition`, language, emitIdentifier)
+    writer.mapped(" ? ", {mappingKind: "exact", node: expression, path, role: "operator"})
+    emitExpression(writer, expression.consequent, `${path}/consequent`, language, emitIdentifier)
+    writer.mapped(" : ", {mappingKind: "exact", node: expression, path, role: "colon"})
+    emitExpression(writer, expression.alternate, `${path}/alternate`, language, emitIdentifier)
+    writer.mapped(")", {mappingKind: "anchor", node: expression, path})
+    return
+  }
+
   if (expression.kind == "UnaryExpression") {
     if (language == "dart" && expression.operation == "IntegerNegate") {
       emitDartIntegerHelper(writer, expression, path, "_semantifoldIntegerNegate", [

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/frontends/java.js

@@ -329,6 +329,29 @@ function convertExpression(node, filename, source, context, expectedType) {
     return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
   }
 
+  if (node.name == "TernaryExpression") {
+    const children = directChildren(node)
+    const question = children.find((child) => child.name == "?" || (child.name == "LogicOp" && nodeText(child, source) == "?"))
+    const colon = children.find((child) => child.name == ":" || (child.name == "LogicOp" && nodeText(child, source) == ":"))
+    const named = children.filter((child) => child !== question && child !== colon)
+
+    if (!question || !colon || named.length != 3) return unsupportedSyntax("java", "ternary expression", location)
+
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(named[2], filename, source, context),
+      condition: convertExpression(named[0], filename, source, context),
+      consequent: convertExpression(named[1], filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: nodeLocation(named[2], filename, source),
+      colon: nodeLocation(colon, filename, source),
+      condition: nodeLocation(named[0], filename, source),
+      consequent: nodeLocation(named[1], filename, source),
+      operator: nodeLocation(question, filename, source)
+    })))
+  }
+
   if (node.name == "MethodInvocation") {
     if (isEqualsInvocation(node, source) && !isZeroArgumentRecordMemberInvocation(node, filename, source, context)) {
       const methodName = requiredChild(node, "MethodName", filename, source)
@@ -626,6 +649,7 @@ function isSupportedExpressionNode(node) {
     "StringLiteral",
     "UnaryExpression",
     "BinaryExpression",
+    "TernaryExpression",
     "MethodInvocation",
     "ObjectCreationExpression",
     "FieldAccess",