semantifold 0.3.0 → 0.4.0

package/src/backends/python.js

@@ -81,15 +81,18 @@ function emitStatement(writer, statement, indent, path) {
     emitIf(writer, statement, indent, path, "if")
     return
   }
+  if (statement.kind == "ExpressionStatement") throw new TypeError("Python Task 005 expression statement reached emission.")
 
   writer.synthetic(indent, "indentation", [statement], [path])
   if (statement.kind == "ReturnStatement") {
+    if (!statement.expression) throw new TypeError("Python bare return reached emission.")
     writer.mapped("return", {mappingKind: "anchor", node: statement, path})
     writer.synthetic(" ", "return spacing", [statement], [path])
     emitExpression(writer, statement.expression, `${path}/expression`, "python", identity)
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }
+  if (statement.kind != "PrintStatement") throw new TypeError("Unsupported Python statement reached emission.")
 
   writer.mapped("print", {mappingKind: "anchor", node: statement, path})
   writer.mapped("(", {mappingKind: "anchor", node: statement, path})

package/src/backends/ruby.js

@@ -1,7 +1,7 @@
 // @ts-check
 
-import {emitExpression} from "./shared.js"
-import {emitScalarType} from "./scalars.js"
+import {emitExpression, emitType} from "./shared.js"
+import {emitEffectPrefixes, emitEffectSupport} from "./effects.js"
 
 /**
  * Emits an independently executable Ruby program through the source-aware writer.
@@ -10,30 +10,116 @@ import {emitScalarType} from "./scalars.js"
  * @returns {void}
  */
 export function generateRuby(module, writer) {
+  const records = module.records ?? []
+  const classes = module.classes ?? []
+  const errors = module.errors ?? []
+
+  if (writer.program) {
+    const programModule = /** @type {import("../semantic/types.js").SemanticProgramModule} */ (/** @type {unknown} */ (module))
+
+    for (const moduleId of [...new Set(programModule.imports.map((item) => item.moduleId))]) {
+      const relative = writer.relativeModuleSpecifier(moduleId).replace(/\.rb$/u, "").replace(/^\.\//u, "")
+      const imported = /** @type {import("../semantic/types.js").SemanticImport} */ (
+        programModule.imports.find((item) => item.moduleId == moduleId))
+      const importPath = `/imports/${programModule.imports.indexOf(imported)}`
+
+      writer.synthetic("require_relative ", "Ruby require-relative edge", [imported], [importPath])
+      writer.mapped(JSON.stringify(relative), {mappingKind: "anchor", node: imported, path: importPath, role: "path"})
+      writer.synthetic("\n", "Ruby require-relative terminator", [imported], [importPath])
+    }
+    if (programModule.imports.length > 0) writer.synthetic("\n", "Ruby require/module separator", [module])
+    if (writer.stdlibProviderEntries) {
+      const relative = writer.stdlibProviderSpecifier().replace(/\.rb$/u, "").replace(/^\.\//u, "")
+
+      writer.synthetic("require_relative ", "Ruby stdlib provider require-relative edge", [module])
+      writer.synthetic(JSON.stringify(relative), "Ruby stdlib provider require-relative path", [module])
+      writer.synthetic("\n", "Ruby stdlib provider require-relative terminator", [module])
+      writer.synthetic("\n", "Ruby stdlib provider require separator", [module])
+    }
+    writer.synthetic(`module ${writer.programModuleName(programModule.id)}\n`, "Ruby semantic module wrapper", [module])
+    if (module.functions.length > 0) writer.synthetic("module_function\n\n", "Ruby module-function profile", [module])
+  }
+
+  emitEffectSupport(writer, module, "ruby")
+  errors.forEach((error, index) => {
+    const path = `/errors/${index}`
+
+    if (index > 0) writer.synthetic("\n\n", "error declaration separator", [error], [path])
+    writer.mapped("class", {mappingKind: "anchor", node: error, path})
+    writer.synthetic(" ", "error declaration spacing", [error], [path])
+    writer.mapped(error.name, {mappingKind: "exact", node: error, path, role: "name"})
+    writer.synthetic(" < StandardError\nend", "Ruby unchecked error scaffolding", [error], [path])
+  })
+  if (errors.length > 0) writer.synthetic("\n\n", "error/declaration separator", [module])
+
+  records.forEach((record, recordIndex) => {
+    const recordPath = `/records/${recordIndex}`
+
+    if (recordIndex > 0) writer.synthetic("\n\n", "record declaration separator", [record], [recordPath])
+    emitTemplateComments(writer, record.typeParameters ?? [], `${recordPath}/typeParameters`)
+    writer.mapped("class", {mappingKind: "anchor", node: record, path: recordPath})
+    writer.synthetic(" ", "record declaration spacing", [record], [recordPath])
+    writer.mapped(record.name, {mappingKind: "exact", node: record, path: recordPath, role: "name"})
+    writer.synthetic("\n", "line break", [record], [recordPath])
+    record.fields.forEach((field, fieldIndex) => {
+      const fieldPath = `${recordPath}/fields/${fieldIndex}`
+
+      writer.synthetic("  # @type [", "Ruby record field type scaffolding", [field], [fieldPath])
+      emitType(writer, field.type, `${fieldPath}/type`, "ruby")
+      writer.synthetic("]\n  attr_reader :", "Ruby record reader scaffolding", [field], [fieldPath])
+      writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+      writer.synthetic("\n", "line break", [field], [fieldPath])
+    })
+    writer.synthetic("\n", "record constructor separator", [record], [recordPath])
+    record.fields.forEach((field, fieldIndex) => {
+      const fieldPath = `${recordPath}/fields/${fieldIndex}`
+
+      writer.synthetic("  # @param ", "Ruby record constructor type scaffolding", [field], [fieldPath])
+      writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+      writer.synthetic(" [", "Ruby record constructor type scaffolding", [field], [fieldPath])
+      emitType(writer, field.type, `${fieldPath}/type`, "ruby")
+      writer.synthetic("]\n", "Ruby record constructor type scaffolding", [field], [fieldPath])
+    })
+    writer.synthetic("  def initialize(", "Ruby record constructor scaffolding", [record], [recordPath])
+    record.fields.forEach((field, fieldIndex) => {
+      if (fieldIndex) writer.synthetic(", ", "record field separator", [record], [recordPath])
+      writer.mapped(field.name, {mappingKind: "exact", node: field, path: `${recordPath}/fields/${fieldIndex}`, role: "name"})
+    })
+    writer.synthetic(")\n", "Ruby record constructor scaffolding", [record], [recordPath])
+    record.fields.forEach((field, fieldIndex) => {
+      const fieldPath = `${recordPath}/fields/${fieldIndex}`
+
+      writer.synthetic("    @", "Ruby record storage scaffolding", [field], [fieldPath])
+      writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+      writer.synthetic(" = ", "Ruby record storage scaffolding", [field], [fieldPath])
+      writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+      writer.synthetic("\n", "line break", [field], [fieldPath])
+    })
+    writer.synthetic("    ::Kernel.instance_method(:freeze).bind_call(self)\n  end\nend", "Ruby record immutability scaffolding", [record], [recordPath])
+  })
+  if (records.length > 0) writer.synthetic("\n\n", "record/function separator", [module])
+
+  classes.forEach((declaration, classIndex) => {
+    if (classIndex > 0) writer.synthetic("\n\n", "reference class separator", [declaration], [`/classes/${classIndex}`])
+    emitReferenceClass(writer, declaration, classIndex)
+  })
+  if (classes.length > 0) writer.synthetic("\n\n", "reference class/function separator", [module])
+
   module.functions.forEach((declaration, functionIndex) => {
     if (functionIndex > 0) writer.synthetic("\n\n", "declaration separator", [declaration])
 
+    emitTemplateComments(writer, declaration.typeParameters ?? [], `/functions/${functionIndex}/typeParameters`)
     for (const [parameterIndex, parameter] of declaration.parameters.entries()) {
       const parameterPath = `/functions/${functionIndex}/parameters/${parameterIndex}`
 
       writer.synthetic("# @param ", "Ruby type scaffolding", [parameter], [parameterPath])
       writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
       writer.synthetic(" [", "Ruby type scaffolding", [parameter], [parameterPath])
-      writer.mapped(emitScalarType("ruby", parameter.type), {
-        mappingKind: "exact",
-        node: parameter.type,
-        path: `${parameterPath}/type`,
-        role: "type"
-      })
+      emitType(writer, parameter.type, `${parameterPath}/type`, "ruby")
       writer.synthetic("]\n", "Ruby type scaffolding", [parameter], [parameterPath])
     }
     writer.synthetic("# @return [", "Ruby type scaffolding", [declaration])
-    writer.mapped(emitScalarType("ruby", declaration.returnType), {
-      mappingKind: "exact",
-      node: declaration.returnType,
-      path: `/functions/${functionIndex}/returnType`,
-      role: "type"
-    })
+    emitType(writer, declaration.returnType, `/functions/${functionIndex}/returnType`, "ruby")
     writer.synthetic("]\n", "Ruby type scaffolding", [declaration])
     writer.mapped("def", {mappingKind: "anchor", node: declaration})
     writer.synthetic(" ", "function spacing", [declaration])
@@ -55,8 +141,129 @@ export function generateRuby(module, writer) {
     writer.mapped("end", {mappingKind: "anchor", node: declaration})
   })
 
-  writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
-  emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body")
+  if (writer.program) {
+    const privateNominals = [...errors, ...records].filter((declaration) => !writer.isExported(declaration.id))
+    const privateFunctions = module.functions.filter((declaration) => !writer.isExported(declaration.id))
+
+    for (const declaration of privateNominals) {
+      writer.synthetic("\nprivate_constant :", "Ruby private semantic nominal declaration", [declaration])
+      writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, role: "name"})
+    }
+    for (const declaration of privateFunctions) {
+      writer.synthetic("\nprivate_class_method :", "Ruby private semantic function", [declaration])
+      writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, role: "name"})
+    }
+  }
+
+  if (!writer.program || writer.isProgramEntry()) {
+    writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
+    emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body")
+  }
+  if (writer.program) writer.synthetic("\nend\n", "Ruby semantic module close", [module])
+}
+
+/**
+ * Emits one native Ruby reference class.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").ClassDeclaration} declaration - Reference class.
+ * @param {number} classIndex - Module class index.
+ * @returns {void}
+ */
+function emitReferenceClass(writer, declaration, classIndex) {
+  const path = `/classes/${classIndex}`
+
+  writer.mapped("class", {mappingKind: "anchor", node: declaration, path})
+  writer.synthetic(" ", "reference class spacing", [declaration], [path])
+  writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, path, role: "name"})
+  writer.synthetic("\n", "line break", [declaration], [path])
+  declaration.fields.forEach((field, index) => {
+    const fieldPath = `${path}/fields/${index}`
+
+    writer.synthetic("  # @semantifold-private ", "private field metadata", [field], [fieldPath])
+    writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+    writer.synthetic(" [", "private field type metadata", [field], [fieldPath])
+    emitType(writer, field.type, `${fieldPath}/type`, "ruby")
+    writer.synthetic("]\n", "line break", [field], [fieldPath])
+  })
+  const constructor = declaration.constructor
+  const constructorPath = `${path}/constructor`
+
+  writer.synthetic("\n", "constructor spacing", [constructor], [constructorPath])
+  emitRubyCallableComments(writer, constructor.parameters, undefined, `${constructorPath}/parameters`, undefined)
+  writer.synthetic("  ", "constructor indentation", [constructor], [constructorPath])
+  writer.mapped("def initialize", {mappingKind: "exact", node: constructor, path: constructorPath, role: "constructor"})
+  emitRubyParameters(writer, constructor.parameters, `${constructorPath}/parameters`)
+  writer.synthetic("\n", "line break", [constructor], [constructorPath])
+  emitBlock(writer, constructor.body, "    ", `${constructorPath}/body`)
+  writer.synthetic("  end", "constructor close", [constructor], [constructorPath])
+  declaration.methods.forEach((method, index) => {
+    const methodPath = `${path}/methods/${index}`
+
+    writer.synthetic("\n\n", "method spacing", [method], [methodPath])
+    emitRubyCallableComments(writer, method.parameters, method.returnType, `${methodPath}/parameters`, `${methodPath}/returnType`)
+    writer.synthetic("  def ", "method indentation", [method], [methodPath])
+    writer.mapped(method.name, {mappingKind: "exact", node: method, path: methodPath, role: "name"})
+    emitRubyParameters(writer, method.parameters, `${methodPath}/parameters`)
+    writer.synthetic("\n", "line break", [method], [methodPath])
+    emitBlock(writer, method.body, "    ", `${methodPath}/body`)
+    writer.synthetic("  end", "method close", [method], [methodPath])
+  })
+  writer.synthetic("\n", "line break", [declaration], [path])
+  writer.mapped("end", {mappingKind: "anchor", node: declaration, path})
+}
+
+/**
+ * Emits exact Ruby callable type comments.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Parameter[]} parameters - Ordered parameters.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType | undefined} returnType - Optional return type.
+ * @param {string} parameterPath - Parameter collection path.
+ * @param {string | undefined} returnPath - Return type path.
+ * @returns {void}
+ */
+function emitRubyCallableComments(writer, parameters, returnType, parameterPath, returnPath) {
+  for (const [index, parameter] of parameters.entries()) {
+    writer.synthetic("  # @param ", "parameter type metadata", [parameter], [`${parameterPath}/${index}`])
+    writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: `${parameterPath}/${index}`, role: "name"})
+    writer.synthetic(" [", "parameter type metadata", [parameter], [`${parameterPath}/${index}`])
+    emitType(writer, parameter.type, `${parameterPath}/${index}/type`, "ruby")
+    writer.synthetic("]\n", "line break", [parameter])
+  }
+  if (returnType && returnPath) {
+    writer.synthetic("  # @return [", "return type metadata", [])
+    emitType(writer, returnType, returnPath, "ruby")
+    writer.synthetic("]\n", "line break", [])
+  }
+}
+
+/**
+ * Emits one Ruby parameter list.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Parameter[]} parameters - Ordered parameters.
+ * @param {string} path - Parameter collection path.
+ * @returns {void}
+ */
+function emitRubyParameters(writer, parameters, path) {
+  writer.synthetic("(", "parameter list open", parameters)
+  parameters.forEach((parameter, index) => {
+    if (index) writer.synthetic(", ", "parameter separator", parameters)
+    writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: `${path}/${index}`, role: "name"})
+  })
+  writer.synthetic(")", "parameter list close", parameters)
+}
+
+/**
+ * Emits exact RDoc declaration parameters.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").TypeParameter[]} parameters - Ordered type parameters.
+ * @param {string} path - Type-parameter collection path.
+ */
+function emitTemplateComments(writer, parameters, path) {
+  parameters.forEach((parameter, index) => {
+    writer.synthetic("# @template ", "Ruby type parameter scaffolding", [parameter], [`${path}/${index}`])
+    writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: `${path}/${index}`, role: "name"})
+    writer.synthetic("\n", "line break", [parameter])
+  })
 }
 
 /**
@@ -80,11 +287,112 @@ function emitBlock(writer, block, indent, path) {
  * @returns {void}
  */
 function emitStatement(writer, statement, indent, path) {
+  emitEffectPrefixes(writer, statement, indent, path, "ruby",
+    (expression, expressionPath) => emitExpression(writer, expression, expressionPath, "ruby", identity))
   if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") return emitLocal(writer, statement, indent, path)
   writer.synthetic(indent, "indentation", [statement], [path])
+  if (statement.kind == "PrivateFieldWriteStatement") {
+    const field = writer.privateFieldForId(statement.field)
+
+    writer.mapped(`@${field.name}`, {mappingKind: "exact", name: field.name, node: statement, path, role: "member"})
+    writer.synthetic(" = ", "private field assignment", [statement], [path])
+    emitExpression(writer, statement.expression, `${path}/expression`, "ruby", identity)
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "BreakStatement" || statement.kind == "ContinueStatement") {
+    writer.mapped(statement.kind == "BreakStatement" ? "break" : "next", {mappingKind: "exact", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "WhileStatement") {
+    writer.mapped("while", {mappingKind: "exact", node: statement, path})
+    writer.synthetic(" ", "condition-controlled loop spacing", [statement], [path])
+    emitExpression(writer, statement.condition, `${path}/condition`, "ruby", identity)
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("end", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "ForEachStatement") {
+    emitExpression(writer, statement.list, `${path}/list`, "ruby", identity)
+    writer.mapped(".each", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "loop spacing", [statement], [path])
+    writer.mapped("do", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic(" |", "iteration binding delimiter", [statement.valueBinding], [`${path}/valueBinding`])
+    writer.mapped(statement.valueBinding.name, {
+      mappingKind: "exact", node: statement.valueBinding, path: `${path}/valueBinding`, role: "name"
+    })
+    writer.synthetic("|\n", "iteration binding delimiter", [statement.valueBinding], [`${path}/valueBinding`])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("end", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "ForEachMapStatement") {
+    emitExpression(writer, statement.map, `${path}/map`, "ruby", identity)
+    writer.mapped(".each", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "map loop spacing", [statement], [path])
+    writer.mapped("do", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic(" |", "map iteration binding delimiter", [statement], [path])
+    writer.mapped(statement.keyBinding.name, {
+      mappingKind: "exact", node: statement.keyBinding, path: `${path}/keyBinding`, role: "name"
+    })
+    writer.synthetic(", ", "map iteration binding separator", [statement], [path])
+    writer.mapped(statement.valueBinding.name, {
+      mappingKind: "exact", node: statement.valueBinding, path: `${path}/valueBinding`, role: "name"
+    })
+    writer.synthetic("|\n", "map iteration binding delimiter", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("end", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "RaiseStatement") {
+    const type = statement.error.error
+    const error = writer.errorForId(type.declarationId)
+
+    writer.mapped("raise", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "raise spacing", [statement], [path])
+    writer.mapped(writer.errorNameForId(type.declarationId), {mappingKind: "exact", name: error.name, node: statement.error, path: `${path}/error`, role: "type"})
+    writer.synthetic(", ", "error message separator", [statement.error], [`${path}/error`])
+    emitExpression(writer, statement.error.message, `${path}/error/message`, "ruby", identity)
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "TryStatement") {
+    const caught = writer.errorForId(statement.catchType.declarationId)
+
+    writer.mapped("begin", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("rescue", {mappingKind: "anchor", node: statement, path, role: "catch"})
+    writer.synthetic(" ", "rescue spacing", [statement], [path])
+    writer.mapped(writer.errorNameForId(statement.catchType.declarationId), {mappingKind: "exact", name: caught.name, node: statement.catchType, path: `${path}/catchType`, role: "type"})
+    writer.synthetic(" => ", "catch binding separator", [statement.catchBinding], [`${path}/catchBinding`])
+    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.catchBody, `${indent}  `, `${path}/catchBody`)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("end", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
   if (statement.kind == "ReturnStatement") {
     writer.mapped("return", {mappingKind: "anchor", node: statement, path})
-    writer.synthetic(" ", "return spacing", [statement], [path])
+    if (statement.expression) {
+      writer.synthetic(" ", "return spacing", [statement], [path])
+      emitExpression(writer, statement.expression, `${path}/expression`, "ruby", identity)
+    }
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "ExpressionStatement") {
     emitExpression(writer, statement.expression, `${path}/expression`, "ruby", identity)
     writer.synthetic("\n", "line break", [statement], [path])
     return
@@ -134,12 +442,7 @@ function emitLocal(writer, statement, indent, statementPath) {
   }
 
   writer.synthetic("# @type [", "Ruby local type scaffolding", [statement], [statementPath])
-  writer.mapped(emitScalarType("ruby", statement.type), {
-    mappingKind: "exact",
-    node: statement.type,
-    path: `${statementPath}/type`,
-    role: "type"
-  })
+  emitType(writer, statement.type, `${statementPath}/type`, "ruby")
   writer.synthetic("]\n", "Ruby local type scaffolding", [statement], [statementPath])
   if (!statement.mutable) {
     writer.synthetic(`${indent}# @semantifold-immutable\n`, "Ruby immutability scaffolding", [statement], [statementPath])

package/src/backends/rust-runtime.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+/** Qualified edition-2021 support. Every token is checked by the Rust frontend before collapse. */
+export const rustRuntime = `#![allow(dead_code, unused_variables, unused_mut, unused_assignments, unused_parens, unconditional_recursion, non_snake_case)]
+fn semantifold_print_integer(value: i64) { println!("{}", value); }
+fn semantifold_print_boolean(value: bool) { println!("{}", value); }
+fn semantifold_print_string(value: String) { println!("{}", value); }
+fn semantifold_integer_add(left: i64, right: i64) -> i64 {
+    let (result, overflow): (i64, bool) = left.overflowing_add(right);
+    if overflow { eprintln!("semantifold: integer overflow"); std::process::exit(70); }
+    return result;
+}
+fn semantifold_integer_subtract(left: i64, right: i64) -> i64 {
+    let (result, overflow): (i64, bool) = left.overflowing_sub(right);
+    if overflow { eprintln!("semantifold: integer overflow"); std::process::exit(70); }
+    return result;
+}
+fn semantifold_integer_multiply(left: i64, right: i64) -> i64 {
+    let (result, overflow): (i64, bool) = left.overflowing_mul(right);
+    if overflow { eprintln!("semantifold: integer overflow"); std::process::exit(70); }
+    return result;
+}
+fn semantifold_integer_negate(value: i64) -> i64 {
+    let (result, overflow): (i64, bool) = value.overflowing_neg();
+    if overflow { eprintln!("semantifold: integer overflow"); std::process::exit(70); }
+    return result;
+}
+`
+
+/** Actual manifest qualified with Cargo 1.98.1 on Ubuntu 24.04 and 26.04. */
+export const rustManifest = '[package]\nname = "semantifold-generated"\nversion = "0.0.0"\nedition = "2021"\nrust-version = "1.98.1"\npublish = false\nbuild = false\n\n[profile.dev]\noverflow-checks = true\npanic = "abort"\n\n[profile.release]\noverflow-checks = true\npanic = "abort"\n'
+
+/** Cargo-generated bytes, SHA-256 185a41f6648ef49c8e7721f3321604abf05fae11c7007f823121c17fe48eec64. */
+export const rustLockfile = '# This file is automatically @generated by Cargo.\n# It is not intended for manual editing.\nversion = 4\n\n[[package]]\nname = "semantifold-generated"\nversion = "0.0.0"\n'

package/src/backends/rust-validation.js

@@ -0,0 +1,75 @@
+// @ts-check
+
+import {unsupportedCapability} from "../diagnostic.js"
+
+/** Qualified legacy Rust grammar input limit, including support source. */
+export const maximumRustSourceLength = 32767
+
+/** Propagates known owned UTF-8 lengths to reject impossible native allocations before emission. */
+class RustValueValidator {
+  /**
+   * Validates each expression without folding or changing the semantic graph.
+   * @param {import("../semantic/types.js").Expression} expression - Validated expression.
+   * @param {Map<string, bigint | undefined>} sizes - Known lexical string byte sizes.
+   * @returns {bigint | undefined} Proven result size when known.
+   */
+  size(expression, sizes) {
+    if (expression.kind == "StringLiteral") return BigInt(Buffer.byteLength(expression.value, "utf8"))
+    if (expression.kind == "IdentifierExpression") return sizes.get(expression.name)
+    if (expression.kind == "CallExpression") {
+      for (const argument of expression.arguments) this.size(argument, sizes)
+    } else if (expression.kind == "UnaryExpression") this.size(expression.operand, sizes)
+    else if (expression.kind == "BinaryExpression") {
+      const left = this.size(expression.left, sizes)
+      const right = this.size(expression.right, sizes)
+
+      if (expression.operation == "StringConcat") {
+        if ((left ?? 0n) + (right ?? 0n) > 9223372036854775807n) {
+          unsupportedCapability("rust", "known owned string size exceeds the qualified signed-64-bit allocation limit", expression.location)
+        }
+        if (left !== undefined && right !== undefined) return left + right
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * Follows value copies and independent branches, retaining only equal outgoing size proofs.
+   * @param {import("../semantic/types.js").Block} block - Lexical block.
+   * @param {Map<string, bigint | undefined>} inherited - Visible sizes.
+   * @returns {Map<string, bigint | undefined>} Outgoing size proofs.
+   */
+  block(block, inherited) {
+    const sizes = new Map(inherited)
+
+    for (const statement of block.statements) {
+      if (statement.kind == "LocalDeclaration") sizes.set(statement.name, this.size(statement.initializer, sizes))
+      else if (statement.kind == "AssignmentStatement") sizes.set(statement.target.name, this.size(statement.expression, sizes))
+      else if (statement.kind == "IfStatement") {
+        this.size(statement.condition, sizes)
+        const left = this.block(statement.consequent, sizes)
+        const right = statement.alternate ? this.block(statement.alternate, sizes) : sizes
+
+        for (const name of sizes.keys()) sizes.set(name, left.get(name) === right.get(name) ? left.get(name) : undefined)
+      } else if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ||
+        statement.kind == "ReturnStatement") {
+        const expression = statement.expression
+
+        if (expression) this.size(expression, sizes)
+      }
+    }
+    return sizes
+  }
+}
+
+/**
+ * Rejects statically unrepresentable owned values before constructing any artifacts.
+ * @param {import("../semantic/types.js").SemanticModule} module - Fully validated semantics.
+ * @returns {void}
+ */
+export function validateRustValues(module) {
+  const validator = new RustValueValidator()
+
+  for (const declaration of module.functions) validator.block(declaration.body, new Map())
+  validator.block(module.entryPoint.body, new Map())
+}