semantifold 0.1.1 → 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/python.js

@@ -0,0 +1,175 @@
+// @ts-check
+
+import {emitExpression} from "./shared.js"
+import {emitScalarType} from "./scalars.js"
+
+/**
+ * Emits one deterministic standalone Python program.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export function generatePython(module, writer) {
+  module.functions.forEach((declaration, functionIndex) => {
+    if (functionIndex > 0) writer.synthetic("\n\n", "declaration separator", [declaration])
+
+    writer.mapped("def", {mappingKind: "anchor", node: declaration})
+    writer.synthetic(" ", "function spacing", [declaration])
+    writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, role: "name"})
+    writer.mapped("(", {mappingKind: "anchor", node: declaration})
+    declaration.parameters.forEach((parameter, parameterIndex) => {
+      const parameterPath = `/functions/${functionIndex}/parameters/${parameterIndex}`
+
+      if (parameterIndex > 0) writer.synthetic(", ", "parameter separator", [declaration])
+      writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
+      writer.synthetic(": ", "Python annotation separator", [parameter], [parameterPath])
+      writer.mapped(emitScalarType("python", parameter.type), {
+        mappingKind: "exact",
+        node: parameter.type,
+        path: `${parameterPath}/type`,
+        role: "type"
+      })
+    })
+    writer.mapped(")", {mappingKind: "anchor", node: declaration})
+    writer.synthetic(" -> ", "Python return annotation separator", [declaration])
+    writer.mapped(emitScalarType("python", declaration.returnType), {
+      mappingKind: "exact",
+      node: declaration.returnType,
+      path: `/functions/${functionIndex}/returnType`,
+      role: "type"
+    })
+    writer.mapped(":", {mappingKind: "anchor", node: declaration})
+    writer.synthetic("\n", "line break", [declaration])
+    emitBlock(writer, declaration.body, "    ", `/functions/${functionIndex}/body`)
+  })
+
+  writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
+  emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body")
+}
+
+/**
+ * Emits one Python indentation block, using pass only for an empty semantic block.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact block path.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path) {
+  if (block.statements.length == 0) {
+    writer.synthetic(`${indent}pass\n`, "Python empty block", [block], [path])
+    return
+  }
+
+  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`))
+}
+
+/**
+ * Emits one supported Python statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact statement path.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path) {
+  if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") {
+    emitLocal(writer, statement, indent, path)
+    return
+  }
+  if (statement.kind == "IfStatement") {
+    emitIf(writer, statement, indent, path, "if")
+    return
+  }
+
+  writer.synthetic(indent, "indentation", [statement], [path])
+  if (statement.kind == "ReturnStatement") {
+    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
+  }
+
+  writer.mapped("print", {mappingKind: "anchor", node: statement, path})
+  writer.mapped("(", {mappingKind: "anchor", node: statement, path})
+  emitExpression(writer, statement.expression, `${path}/expression`, "python", identity)
+  writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Emits a Python if or elif and its optional alternative.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").IfStatement} statement - Branch.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact branch path.
+ * @param {"if" | "elif"} keyword - Branch keyword.
+ * @returns {void}
+ */
+function emitIf(writer, statement, indent, path, keyword) {
+  writer.synthetic(indent, "indentation", [statement], [path])
+  writer.mapped(keyword, {mappingKind: "anchor", node: statement, path})
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  emitExpression(writer, statement.condition, `${path}/condition`, "python", identity)
+  writer.mapped(":", {mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent`})
+  writer.synthetic("\n", "line break", [statement], [path])
+  emitBlock(writer, statement.consequent, `${indent}    `, `${path}/consequent`)
+
+  if (!statement.alternate) return
+  if (statement.alternate.statements.length == 1 && statement.alternate.statements[0].kind == "IfStatement") {
+    emitIf(writer, statement.alternate.statements[0], indent, `${path}/alternate/statements/0`, "elif")
+    return
+  }
+
+  writer.synthetic(indent, "indentation", [statement], [path])
+  writer.mapped("else", {mappingKind: "anchor", node: statement, path})
+  writer.mapped(":", {mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate`})
+  writer.synthetic("\n", "line break", [statement], [path])
+  emitBlock(writer, statement.alternate, `${indent}    `, `${path}/alternate`)
+}
+
+/**
+ * Emits one annotated local declaration or plain assignment.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").LocalStatement} statement - Local statement.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact statement path.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, path) {
+  if (statement.kind == "LocalDeclaration" && !statement.mutable) {
+    writer.synthetic(`${indent}# @semantifold-immutable\n`, "Python immutable local carrier", [statement], [path])
+  }
+  writer.synthetic(indent, "indentation", [statement], [path])
+
+  if (statement.kind == "AssignmentStatement") {
+    writer.mapped(statement.target.name, {mappingKind: "exact", node: statement.target, path: `${path}/target`, role: "name"})
+    writer.synthetic(" ", "assignment spacing", [statement], [path])
+    writer.mapped("=", {mappingKind: "exact", node: statement, path, role: "operator"})
+    writer.synthetic(" ", "assignment spacing", [statement], [path])
+    emitExpression(writer, statement.expression, `${path}/expression`, "python", identity)
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+
+  writer.mapped(statement.name, {mappingKind: "exact", node: statement, path, role: "name"})
+  writer.synthetic(": ", "Python annotation separator", [statement], [path])
+  writer.mapped(emitScalarType("python", statement.type), {
+    mappingKind: "exact", node: statement.type, path: `${path}/type`, role: "type"
+  })
+  writer.synthetic(" ", "assignment spacing", [statement], [path])
+  writer.mapped("=", {mappingKind: "exact", node: statement, path, role: "operator"})
+  writer.synthetic(" ", "assignment spacing", [statement], [path])
+  emitExpression(writer, statement.initializer, `${path}/initializer`, "python", identity)
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Returns one unchanged Python identifier.
+ * @param {string} name - Semantic identifier.
+ * @returns {string} Unchanged Python identifier.
+ */
+function identity(name) {
+  return name
+}

package/src/backends/scalars.js

@@ -2,9 +2,14 @@
 
 /** @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"}),
+  python: Object.freeze({boolean: "bool", integer: "int", string: "str"}),
   ruby: Object.freeze({boolean: "bool", integer: "Integer", string: "String"}),
   typescript: Object.freeze({boolean: "boolean", integer: "number", string: "string"})
 })
@@ -34,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

@@ -7,12 +7,12 @@ import {emitStringLiteral} from "./scalars.js"
 
 /** @type {Readonly<Record<import("../semantic/types.js").SemanticUnaryOperation, string>>} */
 const unaryOperationSyntax = Object.freeze({BooleanNot: "!", IntegerNegate: "-"})
-/** @type {Readonly<Record<import("../semantic/types.js").SemanticBinaryOperation, Readonly<{default: string, php?: string, strict?: string}>>>} */
+/** @type {Readonly<Record<import("../semantic/types.js").SemanticBinaryOperation, Readonly<{default: string, php?: string, python?: string, strict?: string}>>>} */
 const binaryOperationSyntax = Object.freeze({
-  BooleanAnd: Object.freeze({default: "&&"}),
+  BooleanAnd: Object.freeze({default: "&&", python: "and"}),
   BooleanEqual: Object.freeze({default: "==", strict: "==="}),
   BooleanNotEqual: Object.freeze({default: "!=", strict: "!=="}),
-  BooleanOr: Object.freeze({default: "||"}),
+  BooleanOr: Object.freeze({default: "||", python: "or"}),
   IntegerAdd: Object.freeze({default: "+"}),
   IntegerEqual: Object.freeze({default: "==", strict: "==="}),
   IntegerGreaterThan: Object.freeze({default: ">"}),
@@ -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,11 +343,15 @@ 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") {
-    writer.mapped(expression.value ? "true" : "false", {mappingKind: "exact", node: expression, path, role: "literal"})
+    const spelling = language == "python" ? expression.value ? "True" : "False" : expression.value ? "true" : "false"
+
+    writer.mapped(spelling, {mappingKind: "exact", node: expression, path, role: "literal"})
     return
   }
   if (expression.kind == "StringLiteral") {
@@ -344,8 +370,15 @@ 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(unaryOperationSyntax[expression.operation], {
+    writer.mapped(language == "python" && expression.operation == "BooleanNot" ? "not " : unaryOperationSyntax[expression.operation], {
       mappingKind: "exact", node: expression, path, role: "operator"
     })
     emitExpression(writer, expression.operand, `${path}/operand`, language, emitIdentifier)
@@ -353,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")
 
@@ -450,6 +496,7 @@ function binaryOperationSpelling(operation, language) {
   const syntax = binaryOperationSyntax[operation]
 
   if (language == "php" && syntax.php) return syntax.php
+  if (language == "python" && syntax.python) return syntax.python
   if ((language == "php" || language == "javascript" || language == "typescript") && syntax.strict) return syntax.strict
 
   return syntax.default