semantifold 0.2.0 → 0.3.0

package/src/backends/ordered-expressions.js

@@ -0,0 +1,161 @@
+// @ts-check
+
+import {createHash} from "node:crypto"
+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 {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */
+/** @typedef {Array<string | number | boolean | Signature>} Signature */
+
+/** Private occurrence-based native expression sequencer; it never rewrites the IR. */
+export class OrderedExpressionPlanner {
+  /**
+   * Indexes already validated callable return types.
+   * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+   * @param {"c" | "cpp"} [language] - Owning backend diagnostic language.
+   */
+  constructor(module, language = "c") {
+    this.language = language
+    this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration.returnType.name]))
+    this.nextTemporary = 1
+  }
+
+  /**
+   * 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.
+   */
+  type(expression, bindings) {
+    if (expression.kind == "IntegerLiteral") return "integer"
+    if (expression.kind == "BooleanLiteral") return "boolean"
+    if (expression.kind == "StringLiteral") return "string"
+    if (expression.kind == "UnaryExpression" || expression.kind == "BinaryExpression") return expression.type
+    const type = expression.kind == "CallExpression" ? this.functions.get(expression.callee) : bindings.get(expression.name)
+
+    if (!type) return unsupportedCapability(this.language, "unresolved expression type", expression.location)
+    return type
+  }
+
+  /**
+   * Plans one expression in semantic order, keeping the short-circuit RHS conditional.
+   * @param {Expression} expression - Original occurrence.
+   * @param {string} path - Occurrence path.
+   * @param {Map<string, Scalar>} bindings - Lexical types.
+   * @param {PlannedStep[]} steps - Enclosing ordered prelude.
+   * @returns {PlannedValue} Pure final value.
+   */
+  plan(expression, path, bindings, steps) {
+    const result = {expression, path, type: this.type(expression, bindings)}
+
+    if (!["CallExpression", "UnaryExpression", "BinaryExpression"].includes(expression.kind)) return result
+    const operands = []
+    /** @type {PlannedStep[] | undefined} */
+    let rightSteps
+
+    if (expression.kind == "CallExpression") {
+      for (const [index, argument] of expression.arguments.entries()) operands.push(this.plan(argument, `${path}/arguments/${index}`, bindings, steps))
+    } else if (expression.kind == "UnaryExpression") operands.push(this.plan(expression.operand, `${path}/operand`, bindings, steps))
+    else if (expression.kind == "BinaryExpression") {
+      operands.push(this.plan(expression.left, `${path}/left`, bindings, steps))
+      if (expression.operation == "BooleanAnd" || expression.operation == "BooleanOr") {
+        const planned = {...result, name: this.allocate(expression)}
+
+        rightSteps = []
+        operands.push(this.plan(expression.right, `${path}/right`, bindings, rightSteps))
+        steps.push({operands, result: planned, rightSteps})
+        return planned
+      }
+      operands.push(this.plan(expression.right, `${path}/right`, bindings, steps))
+    }
+    const planned = {...result, name: this.allocate(expression)}
+
+    steps.push({operands, result: planned})
+    return planned
+  }
+
+  /**
+   * Allocates one bounded deterministic occurrence name.
+   * @param {Expression} expression - Related expression.
+   * @returns {string} Reserved temporary name.
+   */
+  allocate(expression) {
+    if (this.nextTemporary > 999999) return unsupportedCapability(this.language, "ordered-expression occurrence limit", expression.location)
+    return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, "0")}`
+  }
+}
+
+/**
+ * Binds a region marker to its semantic consumer and expression, independently of locations.
+ * The digest detects edits; structural CST validation remains mandatory and authoritative.
+ * @param {import("../semantic/types.js").Statement} statement - Reconstructed or original statement.
+ * @returns {string} Stable SHA-256 profile signature.
+ */
+export function statementSignature(statement) {
+  const consumer = statement.kind == "LocalDeclaration" ? [statement.kind, statement.name, statement.type.name, statement.mutable] :
+    statement.kind == "AssignmentStatement" ? [statement.kind, statement.target.name] : [statement.kind]
+  const expression = statement.kind == "IfStatement" ? statement.condition : statement.kind == "LocalDeclaration" ? statement.initializer : statement.expression
+
+  return createHash("sha256").update(JSON.stringify([consumer, expressionSignature(expression)])).digest("hex")
+}
+
+/**
+ * Serializes only the closed semantic expression fields.
+ * @param {Expression} expression - Expression occurrence.
+ * @returns {Signature} Signature data.
+ */
+function expressionSignature(expression) {
+  if (expression.kind == "IdentifierExpression") return [expression.kind, expression.name]
+  if (expression.kind == "IntegerLiteral" || expression.kind == "BooleanLiteral" || expression.kind == "StringLiteral") return [expression.kind, expression.value]
+  if (expression.kind == "CallExpression") return [expression.kind, expression.callee, ...expression.arguments.map(expressionSignature)]
+  if (expression.kind == "UnaryExpression") return [expression.kind, expression.operation, expression.type, expressionSignature(expression.operand)]
+  return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)]
+}
+
+/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+/**
+ * Plans every occurrence before constructing a writer or exposing either artifact.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+ * @param {"c" | "cpp"} [language] - Native diagnostic owner.
+ * @returns {Map<string, StatementPlan>} Plans indexed by semantic occurrence path.
+ */
+export function planNativeModule(module, language = "c") {
+  const planner = new OrderedExpressionPlanner(module, language)
+  /** @type {Map<string, StatementPlan>} */
+  const plans = new Map()
+
+  /**
+   * Plans one lexical block with independent branch environments.
+   * @param {import("../semantic/types.js").Block} block - Semantic block.
+   * @param {string} path - Occurrence path.
+   * @param {Map<string, import("../semantic/types.js").SemanticTypeName>} inherited - Visible types.
+   * @returns {void}
+   */
+  function visit(block, path, inherited) {
+    const bindings = new Map(inherited)
+
+    block.statements.forEach((statement, index) => {
+      const statementPath = `${path}/statements/${index}`
+      const field = statement.kind == "IfStatement" ? "condition" : statement.kind == "LocalDeclaration" ? "initializer" : "expression"
+      const expression = statement.kind == "IfStatement" ? statement.condition : statement.kind == "LocalDeclaration" ? statement.initializer : statement.expression
+      /** @type {PlannedStep[]} */
+      const steps = []
+      const value = planner.plan(expression, `${statementPath}/${field}`, bindings, 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 == "LocalDeclaration") bindings.set(statement.name, statement.type.name)
+      if (statement.kind == "IfStatement") {
+        visit(statement.consequent, `${statementPath}/consequent`, bindings)
+        if (statement.alternate) visit(statement.alternate, `${statementPath}/alternate`, bindings)
+      }
+    })
+  }
+
+  module.functions.forEach((declaration, index) => visit(declaration.body, `/functions/${index}/body`,
+    new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name]))))
+  visit(module.entryPoint.body, "/entryPoint/body", new Map())
+  return plans
+}

package/src/backends/scalars.js

@@ -2,6 +2,10 @@
 
 /** @type {Readonly<Record<import("../semantic/types.js").SemanticLanguage, Readonly<Record<import("../semantic/types.js").SemanticTypeName, string>>>>} */
 const targetScalarTypes = Object.freeze({
+  cpp: Object.freeze({boolean: "bool", integer: "std::int64_t", string: "std::string"}),
+  c: Object.freeze({boolean: "bool", integer: "int64_t", string: "SemantifoldString"}),
+  csharp: Object.freeze({boolean: "bool", integer: "long", string: "string"}),
+  go: Object.freeze({boolean: "bool", integer: "int64", string: "string"}),
   java: Object.freeze({boolean: "boolean", integer: "int", string: "String"}),
   javascript: Object.freeze({boolean: "boolean", integer: "number", string: "string"}),
   php: Object.freeze({boolean: "bool", integer: "int", string: "string"}),
@@ -35,7 +39,9 @@ export function emitStringLiteral(language, value) {
 
   if (typeof literal != "string") throw new TypeError("A validated semantic string did not serialize.")
 
-  return literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029")
+  const escapedLineSeparators = literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029")
+
+  return language == "csharp" ? escapedLineSeparators.replaceAll("\u0085", "\\u0085") : escapedLineSeparators
 }
 
 /**

package/src/backends/shared.js

@@ -34,11 +34,20 @@ const binaryOperationSyntax = Object.freeze({
  * @returns {void}
  */
 export function validateBackendModule(module, language) {
+  if (!module || typeof module != "object" || Array.isArray(module)) {
+    return unsupportedCapability(language, "missing or invalid module", undefined)
+  }
   if (module.kind != "Module") unsupportedCapability(language, module.kind, module.location)
+  if (!Array.isArray(module.functions) || !module.entryPoint || typeof module.entryPoint != "object" ||
+    module.entryPoint.kind != "EntryPoint") unsupportedCapability(language, "missing or invalid module members", module.location)
   if (module.functions.length == 0) unsupportedCapability(language, "module without functions", module.location)
   validateBlock(module.entryPoint.body, language, module.entryPoint.location)
 
   for (const functionDeclaration of module.functions) {
+    if (!functionDeclaration || typeof functionDeclaration != "object" || Array.isArray(functionDeclaration) ||
+      functionDeclaration.kind != "FunctionDeclaration" || !Array.isArray(functionDeclaration.parameters)) {
+      unsupportedCapability(language, "missing or invalid function declaration", module.location)
+    }
     validateTargetBindingIdentifier(language, functionDeclaration.name, "function", functionDeclaration.location)
 
     if (functionDeclaration.parameters.length != 2) {
@@ -47,10 +56,11 @@ export function validateBackendModule(module, language) {
     validateBlock(functionDeclaration.body, language, functionDeclaration.location)
 
     for (const parameter of functionDeclaration.parameters) {
+      if (!parameter || typeof parameter != "object" || Array.isArray(parameter) || parameter.kind != "Parameter") {
+        unsupportedCapability(language, "missing or invalid parameter", functionDeclaration.location)
+      }
       validateTargetBindingIdentifier(language, parameter.name, "parameter", parameter.location)
-
     }
-
   }
   validateScaffoldingNames(module, language)
   validateBackendTypes(module, language)
@@ -63,11 +73,17 @@ export function validateBackendModule(module, language) {
  * @returns {void}
  */
 function validateScaffoldingNames(module, language) {
-  const ownedEntryNames = language == "java" ? new Set(["args", "System"]) :
+  const ownedEntryNames = language == "go" ? new Set(["fmt", "int64", "bool", "string", "true", "false"]) :
+    language == "csharp" ? new Set(["System"]) : language == "java" ? new Set(["args", "System"]) :
     ["javascript", "typescript"].includes(language) ? new Set(["console"]) : new Set()
-  const ownedPrintReceiverNames = language == "java" ? new Set(["System"]) :
+  const ownedPrintReceiverNames = language == "go" ? new Set(["fmt", "int64", "bool", "string", "true", "false"]) :
+    language == "csharp" || language == "java" ? new Set(["System"]) :
     ["javascript", "typescript"].includes(language) ? new Set(["console"]) : new Set()
-  const ownedCallableNames = ["javascript", "typescript"].includes(language) ? new Set(["console"]) :
+  const ownedCallableNames = language == "go" ? new Set(["main", "init", "fmt", "int64", "bool", "string", "true", "false"]) :
+    language == "csharp" ? new Set([
+    "Equals", "Finalize", "GetHashCode", "GetType", "Main", "MemberwiseClone", "Program", "ReferenceEquals", "System", "ToString"
+  ]) :
+    ["javascript", "typescript"].includes(language) ? new Set(["console"]) :
     language == "ruby" ? new Set(["puts"]) : new Set()
 
   for (const statement of allStatements(module.entryPoint.body)) {
@@ -229,6 +245,10 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
     if (language == "java" && !validNegatedMinimumOperand && (candidate.value < -2147483648 || candidate.value > 2147483647)) {
       unsupportedCapability(language, "integer literal outside signed 32-bit int range", location)
     }
+    if ((language == "csharp" || language == "go" || language == "c" || language == "cpp") && candidate.value < 0 ||
+      (language == "c" || language == "cpp") && Object.is(candidate.value, -0)) {
+      unsupportedCapability(language, "negative integer literal without semantic negation", location)
+    }
     return
   }
   if (candidate.kind == "BooleanLiteral" || candidate.kind == "StringLiteral") return
@@ -248,7 +268,7 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
       unsupportedCapability(language, `unary operation ${String(candidate.operation)}`, location)
     }
     validateExpression(candidate.operand, language, location, candidate.operation == "IntegerNegate")
-    validateKnownJavaInteger(candidate, language, location)
+    validateKnownTargetInteger(candidate, language, location)
     return
   }
   if (candidate.kind == "BinaryExpression") {
@@ -257,7 +277,7 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
     }
     validateExpression(candidate.left, language, location)
     validateExpression(candidate.right, language, location)
-    validateKnownJavaInteger(candidate, language, location)
+    validateKnownTargetInteger(candidate, language, location)
     return
   }
 
@@ -271,14 +291,16 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
  * @param {import("../semantic/types.js").SourceLocation | undefined} location - Operation location.
  * @returns {void}
  */
-function validateKnownJavaInteger(expression, language, location) {
-  if (language != "java") return
-
+function validateKnownTargetInteger(expression, language, location) {
   const value = knownIntegerValue(expression)
 
-  if (value !== undefined && (value < -2147483648n || value > 2147483647n)) {
+  if (language == "java" && value !== undefined && (value < -2147483648n || value > 2147483647n)) {
     unsupportedCapability(language, "compile-time-known integer operation outside signed 32-bit int range", location)
   }
+  if ((language == "csharp" || language == "go" || language == "c" || language == "cpp") && value !== undefined &&
+    (value < -9223372036854775808n || value > 9223372036854775807n)) {
+    unsupportedCapability(language, "compile-time-known integer operation outside signed 64-bit long range", location)
+  }
 }
 
 /**
@@ -321,7 +343,9 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
   if (expression.kind == "IntegerLiteral") {
-    writer.mapped(String(expression.value), {mappingKind: "exact", node: expression, path, role: "literal"})
+    const spelling = language == "csharp" ? `${expression.value}L` : String(expression.value)
+
+    writer.mapped(spelling, {mappingKind: "exact", node: expression, path, role: "literal"})
     return
   }
   if (expression.kind == "BooleanLiteral") {
@@ -346,6 +370,13 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
   }
 
   if (expression.kind == "UnaryExpression") {
+    if (language == "csharp" && expression.operation == "IntegerNegate") {
+      writer.mapped("checked(", {mappingKind: "anchor", node: expression, path})
+      writer.mapped("-", {mappingKind: "exact", node: expression, path, role: "operator"})
+      emitExpression(writer, expression.operand, `${path}/operand`, language, emitIdentifier)
+      writer.mapped(")", {mappingKind: "anchor", node: expression, path})
+      return
+    }
     writer.mapped("(", {mappingKind: "anchor", node: expression, path})
     writer.mapped(language == "python" && expression.operation == "BooleanNot" ? "not " : unaryOperationSyntax[expression.operation], {
       mappingKind: "exact", node: expression, path, role: "operator"
@@ -355,6 +386,19 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
 
+  if (language == "csharp" && ["IntegerAdd", "IntegerSubtract", "IntegerMultiply"].includes(expression.operation)) {
+    writer.mapped("checked(", {mappingKind: "anchor", node: expression, path})
+    emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier)
+    writer.synthetic(" ", "operator spacing", [expression], [path])
+    writer.mapped(binaryOperationSpelling(expression.operation, language), {
+      mappingKind: "exact", node: expression, path, role: "operator"
+    })
+    writer.synthetic(" ", "operator spacing", [expression], [path])
+    emitExpression(writer, expression.right, `${path}/right`, language, emitIdentifier)
+    writer.mapped(")", {mappingKind: "anchor", node: expression, path})
+    return
+  }
+
   if (language == "java" && (expression.operation == "StringEqual" || expression.operation == "StringNotEqual")) {
     const compositeOperator = expression.operation == "StringNotEqual" && writer.hasRange(expression, path, "equalityOperator")
 

package/src/frontends/c-parser.js

@@ -0,0 +1,17 @@
+// @ts-check
+
+import {createRequire} from "node:module"
+
+/**
+ * Parser-neutral read-only data supplied by the frozen private legacy boundary.
+ * @typedef {Readonly<{type: string, named: boolean, extra: boolean, error: boolean, missing: boolean,
+ * hasError: boolean, startIndex: number, endIndex: number,
+ * children: readonly Readonly<{field: string | null, node: CstNode}>[]}>} CstNode
+ */
+/** @typedef {Readonly<{root: CstNode}>} CstSnapshot */
+
+const require = createRequire(import.meta.url)
+const boundary = /** @type {{parseCst: (source: string) => CstSnapshot}} */ (require("semantifold-tree-sitter-legacy-internal"))
+
+/** The root-bundled private parser is the only C parsing implementation. */
+export const parseCst = boundary.parseCst